home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / dev / sun4.md / devSCSI3.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  77KB  |  2,408 lines
  1. /* 
  2.  * devSCSI3.c --
  3.  *
  4.  *    Routines specific to the SCSI-3 Host Adaptor.  This adaptor is
  5.  *    based on the NCR 5380 chip.  There are two variants, one is
  6.  *    "onboard" the main CPU board (3/50, 3/60, 4/110) and uses a
  7.  *    Universal DMA Controller chip, the AMD 9516 UDC.  The other is
  8.  *    on the VME and has a much simpler DMA interface.  Both are
  9.  *    supported here.  The 5380 supports connect/dis-connect.
  10.  *
  11.  * Copyright 1988 Regents of the University of California
  12.  * Permission to use, copy, modify, and distribute this
  13.  * software and its documentation for any purpose and without
  14.  * fee is hereby granted, provided that the above copyright
  15.  * notice appear in all copies.  The University of California
  16.  * makes no representations about the suitability of this
  17.  * software for any purpose.  It is provided "as is" without
  18.  * express or implied warranty.
  19.  */
  20.  
  21. #ifndef lint
  22. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/dev/sun4.md/devSCSI3.c,v 9.6 91/08/19 12:54:31 mendel Exp $ SPRITE (Berkeley)";
  23. #endif /* not lint */
  24.  
  25. #include "sprite.h"
  26. #include "scsi3.h"
  27. #include "mach.h"
  28. #include "dev.h"
  29. #include "devInt.h"
  30. #include "scsiHBA.h"
  31. #include "scsiDevice.h"
  32. #include "sync.h"
  33. #include "stdio.h"
  34. #include "stdlib.h"
  35. #include "string.h"
  36. #include "bstring.h"
  37.  
  38. #include "dbg.h"
  39.  
  40. /*
  41.  *
  42.  *      Definitions for Sun's second variant on the SCSI device interface.
  43.  *    This interface is  found on 32-bit VME versions, i.e. some plug-in
  44.  *    controllers, and the 3/{56}0.  The associated paper reference is
  45.  *    "Hardware Reference Manual for the Sun-3 SCSI Board".  This explains
  46.  *    general behavior of the VME version of the SCSI-3 interface.
  47.  *    The reference for the 5380 is the NCR Standard Products Data Book,
  48.  *    Micro-electronics Division.  Page number references refer to the
  49.  *    4/88 (April 88) edition.  The UDC (Universal DMA Controller) chip
  50.  *    is the AMD 9516 and the AMD reference manual can be consulted for chip
  51.  *    specifics.
  52.  *
  53.  *
  54.  *    The 5380 has 8 general registers.  They have different functions
  55.  *    when read and written.  See pp. 80-85 for register descriptions.
  56.  *    This chip allows direct control over the SCSI bus by the CPU,
  57.  *    so many bits correspond directly to SCSI bus signals.
  58.  */
  59. typedef struct ReadRegs {
  60.     unsigned char data;        /* Data register.  A direct connection to
  61.                  * the SCSI data bus.  This is read during
  62.                  * programmed I/O to get msgs, and during
  63.                  * arbitration. */
  64.     unsigned char initCmd;    /* Initiator command register */
  65.     unsigned char mode;        /* Mode register */
  66.     unsigned char trgtCmd;    /* Target command register */
  67.     unsigned char curStatus;    /* All SCSI signals except ATN and ACK */
  68.     unsigned char status;    /* ATN, ACK, plus DMA and interrupt signals */
  69.     unsigned char inData;    /* Input data register.  Used for "latched"
  70.                  * data on the SCSI bus during DMA.  This
  71.                  * is not accessed directly by the driver. */
  72.     unsigned char clear;    /* Read this to clear the following bits
  73.                  * in the status register: parity error,
  74.                  * interrupt request, busy failure. */
  75. } ReadRegs;
  76.  
  77. /*
  78.  * The following format applies when writing the registers.
  79.  */
  80. typedef struct WriteRegs {
  81.     unsigned char data;        /* Data register.  Contains the ID of the
  82.                  * SCSI "target", or controller, for the 
  83.                  * SELECT phase. Also, leftover odd bytes
  84.                  * are left here after a read. */
  85.     unsigned char initCmd;    /* Initiator command register */
  86.     unsigned char mode;        /* Mode register */
  87.     unsigned char trgtCmd;    /* Target command register */
  88.     unsigned char select;    /* Select/reselect enable register */
  89.     /*
  90.      * DMA is initiated by writing to these registers.  The TARGET mode
  91.      * bit should be set right, i.e. cleared before writing to
  92.      * the send or initRecv registers, and the DMA mode bit should be set.
  93.      */
  94.     unsigned char send;        /* Start DMA from memory to SCSI bus */
  95.     unsigned char trgtRecv;    /* Start DMA from SCSI bus to target */
  96.     unsigned char initRecv;    /* Start DMA from SCSI bus to initiator */
  97. } WriteRegs;
  98.  
  99. /*
  100.  * Control bits in the 5380 Initiator Command Register.
  101.  * RST, ACK, BSY, SEL, ATN are direct connections to SCSI control lines.
  102.  * Setting or clearing the bit raises or lowers the SCSI signal.
  103.  * Reading these bits indicates the current value of the control signal.
  104.  */
  105. #define    SBC_ICR_RST    0x80    /* (r/w) SCSI RST (reset) signal */
  106. #define SBC_ICR_AIP    0x40    /* (r)   arbitration in progress */
  107. #define SBC_ICR_TEST    0x40    /* (w)   test mode, disables output */
  108. #define SBC_ICR_LA    0x20    /* (r)   lost arbitration */
  109. #define SBC_ICR_DE    0x20    /* (w)   differential enable (5381 only) */
  110. #define SBC_ICR_ACK    0x10    /* (r/w) SCSI ACK (acknowledge) signal */
  111. #define SBC_ICR_BUSY    0x08    /* (r/w) SCSI BSY (busy) signal */
  112. #define SBC_ICR_SEL    0x04    /* (r/w) SCSI SEL (select) signal */
  113. #define SBC_ICR_ATN    0x02    /* (r/w) SCSI ATN (attention) signal */
  114. #define SBC_ICR_DATA    0x01    /* (r/w) assert data bus.  Enables the outData
  115.                  * contents to be output on the SCSi data lines.
  116.                  * This should be set during DMA send. */
  117.  
  118. /*
  119.  * Bits in the 5380 Mode Register (same on read or write).
  120.  * "This is used to control the operation of the chip."
  121.  * The mode controls DMA, target/initiator roles, parity, and interrupts.
  122.  */
  123. #define SBC_MR_BDMA    0x80    /* Enable block mode dma */
  124. #define SBC_MR_TRG    0x40    /* Target mode when set, else Initiator */
  125. #define SBC_MR_EPC    0x20    /* Enable parity check */
  126. #define SBC_MR_EPI    0x10    /* Enable parity interrupt */
  127. #define SBC_MR_EEI    0x08    /* Enable eop (end-of-process, dma) interrupt */
  128. #define SBC_MR_MBSY    0x04    /* Enable monitoring of BSY (busy) signal */
  129. #define SBC_MR_DMA    0x02    /* Enable DMA.  Used with other DMA regs. */
  130. #define SBC_MR_ARB    0x01    /* Set during SCSI bus arbitration */
  131.  
  132. /*
  133.  * Bits in the 5380 Target Command Register.
  134.  * As an Initator, which we always are, this register must be set to
  135.  * match the current phase that's on the SCSI bus before sending data.
  136.  */
  137. #define SBC_TCR_REQ    0x08    /* assert request.  Only for targets. */
  138. #define SBC_TCR_MSG    0x04    /* message phase, if set */
  139. #define SBC_TCR_CD    0x02    /* command phase if set, else data phase */
  140. #define SBC_TCR_IO    0x01    /* input phase if set, else output */
  141.  
  142. /*
  143.  * Combinations for different phases as represented in the target cmd. reg.
  144.  */
  145. #define TCR_COMMAND    (SBC_TCR_CD)
  146. #define TCR_STATUS    (SBC_TCR_CD | SBC_TCR_IO)
  147. #define TCR_MSG_OUT    (SBC_TCR_MSG | SBC_TCR_CD)
  148. #define TCR_MSG_IN    (SBC_TCR_MSG | SBC_TCR_CD | SBC_TCR_IO)
  149. #define TCR_DATA_OUT    0
  150. #define TCR_DATA_IN    (SBC_TCR_IO)
  151. #define TCR_UNSPECIFIED    (SBC_TCR_MSG)
  152.  
  153. /*
  154.  * Bits in the 5380 Current SCSI Bus Status register (read only).
  155.  * This register is used to monitor the current state of all of
  156.  * the SCSI bus lines except ATN (attention) and ACK (acknowledge).
  157.  */
  158. #define SBC_CBSR_RST    0x80    /* reset */
  159. #define SBC_CBSR_BSY    0x40    /* busy */
  160. #define SBC_CBSR_REQ    0x20    /* request */
  161. #define SBC_CBSR_MSG    0x10    /* message */
  162. #define SBC_CBSR_CD    0x08    /* command/data */
  163. #define SBC_CBSR_IO    0x04    /* input/output */
  164. #define SBC_CBSR_SEL    0x02    /* select */
  165. #define SBC_CBSR_DBP    0x01    /* data bus parity */
  166.  
  167. /*
  168.  * Combinations for different phases as represented on the SCSI bus.
  169.  * COMMAND phase is used to send a command block to a Target.
  170.  * STATUS phase is used to get status bytes from a Target.
  171.  * MSG_OUT phase is used to send message bytes to a Target.
  172.  * MSG_IN phase is used to get a message from a Target.
  173.  * DATA_OUT phase is used to send data to a Target.
  174.  * DATA_IN phase is used when receiving data from a Target.
  175.  */
  176. #define CBSR_PHASE_BITS    (SBC_CBSR_CD | SBC_CBSR_MSG | SBC_CBSR_IO)
  177. #define PHASE_COMMAND    (SBC_CBSR_CD)
  178. #define PHASE_STATUS    (SBC_CBSR_CD | SBC_CBSR_IO)
  179. #define PHASE_MSG_OUT    (SBC_CBSR_MSG | SBC_CBSR_CD)
  180. #define PHASE_MSG_IN    (SBC_CBSR_MSG | SBC_CBSR_CD | SBC_CBSR_IO)
  181. #define PHASE_DATA_OUT    0
  182. #define PHASE_DATA_IN    (SBC_CBSR_IO)
  183.  
  184. /*
  185.  * Bits in the 5380 Bus and Status register.  This has the ATN and ACK
  186.  * SCSI lines, plus other status bits.
  187.  */
  188. #define SBC_BSR_EDMA    0x80    /* End of dma, almost, see p. 84 */
  189. #define SBC_BSR_RDMA    0x40    /* DRQ (dma request) signal, set during DMA */
  190. #define SBC_BSR_PERR    0x20    /* Parity error */
  191. #define SBC_BSR_INTR    0x10    /* IRQ (interrupt request) */
  192. #define SBC_BSR_PMTCH    0x08    /* Phase match indicates if trgtCmd is ok */
  193. #define SBC_BSR_BERR    0x04    /* Busy error set when BSY goes away */
  194. #define SBC_BSR_ATN    0x02    /* SCSI ATN (attention) signal */
  195. #define SBC_BSR_ACK    0x01    /* SCSI ACK (acknowledge)_signal */
  196.  
  197. /*
  198.  * AMD 9516 UDC (Universal DMA Controller) Registers.
  199.  * Sun3/50 and Sun3/60.
  200.  */
  201.  
  202. /* addresses of the udc registers accessed directly by driver */
  203. #define UDC_ADR_MODE        0x38    /* master mode register */
  204. #define UDC_ADR_COMMAND        0x2e    /* command register (write only) */
  205. #define UDC_ADR_STATUS        0x2e    /* status register (read only) */
  206. #define UDC_ADR_CAR_HIGH    0x26    /* chain addr reg, high word */
  207. #define UDC_ADR_CAR_LOW        0x22    /* chain addr reg, low word */
  208. #define UDC_ADR_CARA_HIGH    0x1a    /* cur addr reg A, high word */
  209. #define UDC_ADR_CARA_LOW    0x0a    /* cur addr reg A, low word */
  210. #define UDC_ADR_CARB_HIGH    0x12    /* cur addr reg B, high word */
  211. #define UDC_ADR_CARB_LOW    0x02    /* cur addr reg B, low word */
  212. #define UDC_ADR_CMR_HIGH    0x56    /* channel mode reg, high word */
  213. #define UDC_ADR_CMR_LOW        0x52    /* channel mode reg, low word */
  214. #define UDC_ADR_COUNT        0x32    /* number of words to transfer */
  215.  
  216. /* 
  217.  * For a dma transfer, the appropriate udc registers are loaded from a 
  218.  * table in memory pointed to by the chain address register.
  219.  */
  220. typedef struct UDCDMAtable {
  221.     unsigned short    rsel;    /* tells udc which regs to load */
  222.     unsigned short    haddr;    /* high word of main mem dma address */
  223.     unsigned short    laddr;    /* low word of main mem dma address */
  224.     unsigned short    count;    /* num words to transfer */
  225.     unsigned short    hcmr;    /* high word of channel mode reg */
  226.     unsigned short    lcmr;    /* low word of channel mode reg */
  227. } UDCDMAtable;
  228.  
  229. /* indicates which udc registers are to be set based on info in above table */
  230. #define UDC_RSEL_RECV        0x0182
  231. #define UDC_RSEL_SEND        0x0282
  232.  
  233. /* setting of chain mode reg: selects how the dma op is to be executed */
  234. #define UDC_CMR_HIGH        0x0040    /* high word of channel mode reg */
  235. #define UDC_CMR_LSEND        0x00c2    /* low word of cmr when send */
  236. #define UDC_CMR_LRECV        0x00d2    /* low word of cmr when receiving */
  237.  
  238. /* setting for the master mode register */
  239. #define UDC_MODE        0xd    /* enables udc chip */
  240.  
  241. /* setting for the low byte in the high word of an address */
  242. #define UDC_ADDR_INFO        0x40    /* inc addr after each word is dma'd */
  243.  
  244. /* udc commands */
  245. #define UDC_CMD_STRT_CHN    0xa0    /* start chaining */
  246. #define UDC_CMD_CIE        0x32    /* channel 1 interrupt enable */
  247. #define UDC_CMD_RESET        0x00    /* reset udc, same as hdw reset */
  248.  
  249. /* bits in the udc status register */
  250. #define UDC_SR_CIE        0x8000    /* channel interrupt enable */
  251. #define UDC_SR_IP        0x2000    /* interrupt pending */
  252. #define UDC_SR_CA        0x1000    /* channel abort */
  253. #define UDC_SR_NAC        0x0800    /* no auto reload or chaining*/
  254. #define UDC_SR_WFB        0x0400    /* waiting for bus */
  255. #define UDC_SR_SIP        0x0200    /* second interrupt pending */
  256. #define UDC_SR_HM        0x0040    /* hardware mask */
  257. #define UDC_SR_HRQ        0x0020    /* hardware request */
  258. #define UDC_SR_MCH        0x0010    /* match on upper comparator byte */
  259. #define UDC_SR_MCL        0x0008    /* match on lower comparator byte */
  260. #define UDC_SR_MC        0x0004    /* match condition ended dma */
  261. #define UDC_SR_EOP        0x0002    /* eop condition ended dma */
  262. #define UDC_SR_TC        0x0001    /* termination of count ended dma */
  263.  
  264. /*
  265.  * Misc defines 
  266.  */
  267. /*
  268.  * Values for the reset argument of WaitReg.
  269.  */
  270. #define RESET        TRUE
  271. #define NO_RESET    FALSE
  272.  
  273. /* arbitrary retry count */
  274. #define SI_NUM_RETRIES        2
  275. /*
  276.  * WAIT_LENGTH - the number of microseconds that the host waits for
  277.  *    various control lines to be set on the SCSI bus.  The largest wait
  278.  *    time is when a controller is being selected.  This delay is
  279.  *    called the Bus Abort delay and is about 250 milliseconds.
  280.  */
  281.  
  282. #define    WAIT_LENGTH        250000
  283.  
  284. /* scsi timer values, all in microseconds */
  285. #define SI_ARBITRATION_DELAY    3
  286. #define SI_BUS_CLEAR_DELAY    1
  287. #define SI_BUS_SETTLE_DELAY    1
  288. #define SI_UDC_WAIT        1
  289. #define    SI_WAIT_COUNT        250000
  290.  
  291. /* directions for dma transfers */
  292. #define SI_RECV_DATA        0
  293. #define SI_SEND_DATA        1
  294. #define SI_NO_DATA        2
  295.  
  296. /* initiator's scsi device id */
  297. #define    SI_HOST_ID        0x80
  298. /*
  299.  * INTR_ADDR(vector) - Compute the correct interruptAddr modifier
  300.  * for the VME version of this interface. Vector is the VME interrupt
  301.  * to use.  The high order 8 bits is the address space modiifer.
  302.  * The correct value 0x3d - 24 bit address Supervisor data space. 
  303.  * We shift it right 8 bits to leave room the the interrupt vector
  304.  * we or in.
  305.  */
  306. #define INTR_ADDR(vector)    ((0x3d<<8)|(vector))
  307.  
  308. /*
  309.  * Maximum data transfer size for the onBoard HBA appears to be
  310.  * limited by the 16 bit dma register. Since this counter is in 
  311.  * words we can send up to 127 K but not 128 K. The DMA counter
  312.  * on the VME version is 24 bits.  As it turns out both this values are
  313.  * limited by the size of the mapped DMA buffer DEV_MAX_TRANSFER_SIZE.
  314.  */
  315.  
  316. #define    MAX_ONBOARD_TRANSFER_SIZE    (64*1024)
  317.  
  318. #define    MAX_VME_TRANSFER_SIZE        (128*1024)
  319.  
  320. /* 
  321.  * Register layout for the SCSI control logic interface.
  322.  * Some of these registers apply to only one interface and some
  323.  * apply to both. The registers which apply to the Sun3/50 onboard 
  324.  * version only are udc_rdata and udc_raddr. The registers which
  325.  * apply to the Sun3 vme version only are dma_addr, dma_count, bpr,
  326.  * iv_am, and bcrh. Thus, the sbc registers, fifo_data, bcr, and csr 
  327.  * apply to both interfaces.
  328.  * One other feature of the vme interface: a write to the dma count 
  329.  * register also causes a write to the fifo byte count register and
  330.  * vice-versa.
  331.  */
  332. typedef struct CtrlRegs {
  333.     union {
  334.         struct ReadRegs    read;    /* scsi bus ctrl, read reg */
  335.         struct WriteRegs    write;    /* scsi bus ctrl, write reg */
  336.     } sbc;                    /* SBC 5380 registers, 8 bytes*/
  337.     unsigned short        dmaAddressHigh;    /* dma address register High */
  338.     unsigned short        dmaAddressLow;    /* dma address register Low */
  339.     unsigned short        dmaCountHigh;    /* dma count register High */
  340.     unsigned short        dmaCountLow;    /* dma count register low*/
  341.     unsigned short        udcRdata;    /* UDC, reg data */
  342.     unsigned short        udcRaddr;    /* UDC, reg addr */
  343.     unsigned short        fifoData;    /* fifo data register */
  344.                         /* holds extra byte on odd */
  345.                         /* byte dma read */
  346.     unsigned short        fifoCountLow;    /* fifo byte count reg */
  347.     unsigned short        control;    /* control/status register */
  348.     unsigned short        bytePackHigh;    /* Byte 0 and Byte 1 */
  349.     unsigned short        bytePackLow;    /* Byte 2 and Byte 3 */
  350.     unsigned short        addrIntr;    /* bits 0-7: addr modifier */
  351.                         /* bits 8-13: intr vector */
  352.                         /* bits 14-15: unused */
  353.     unsigned short        fifoCountHigh;    /* high portion of fifoCount */
  354. } CtrlRegs;
  355.  
  356. /*
  357.  * The dmaAddress, dmaCount, and fifoCount are 32 or 24 bit registers with only
  358.  * a 16 bit path to them. Because of this we have the following macros
  359.  * for setting and reading them. 
  360.  * SET_FIFO_COUNT()    - Set the FIFO count register to the provided value.
  361.  * READ_FIFO_COUNT()    - Read the FIFO count register.
  362.  * SET_DMA_COUNT()    - Set the DMA count register to the provided value.
  363.  * READ_DMA_COUNT()    - Read the DMA count register.
  364.  * SET_DMA_ADDR()    - Set the DMA address register to the provided value.
  365.  * READ_DMA_ADDR()    - Read the DMA address register.
  366.  */
  367. #ifdef bigio_works
  368.  
  369. #define    SET_FIFO_COUNT(regsPtr, value)    {\
  370.         (regsPtr)->fifoCountLow = ((unsigned) (value) & 0xffff);          \
  371.         (regsPtr)->fifoCountHigh = (((unsigned)(value) >> 16) & 0xff);    \
  372.     }
  373. #define    READ_FIFO_COUNT(regsPtr)    \
  374.        ((((regsPtr)->fifoCountHigh&0xff) << 16) | ((regsPtr)->fifoCountLow))
  375.  
  376. #define    SET_DMA_COUNT(regsPtr, value)    {\
  377.         (regsPtr)->dmaCountLow = ((unsigned) (value) & 0xffff);          \
  378.         (regsPtr)->dmaCountHigh = (((unsigned)(value) >> 16) & 0xff);    \
  379.         }
  380. #define    READ_DMA_COUNT(regsPtr)    \
  381.         ((((regsPtr)->dmaCountHigh&0xff) << 16) | ((regsPtr)->dmaCountLow))
  382. #else
  383. static int countHighMask = 0;
  384. #define    SET_FIFO_COUNT(regsPtr, value)    {\
  385.         (regsPtr)->fifoCountLow = ((unsigned) (value) & 0xffff);          \
  386.         (regsPtr)->fifoCountHigh = (((unsigned)(value) >> 16) & countHighMask);    \
  387.     }
  388. #define    READ_FIFO_COUNT(regsPtr)    \
  389.        ((((regsPtr)->fifoCountHigh&countHighMask) << 16) | ((regsPtr)->fifoCountLow))
  390.  
  391. #define    SET_DMA_COUNT(regsPtr, value)    {\
  392.         (regsPtr)->dmaCountLow = ((unsigned) (value) & 0xffff);          \
  393.         (regsPtr)->dmaCountHigh = (((unsigned)(value) >> 16) & countHighMask);    \
  394.         }
  395. #define    READ_DMA_COUNT(regsPtr)    \
  396.         ((((regsPtr)->dmaCountHigh&countHighMask) << 16) | ((regsPtr)->dmaCountLow))
  397. #endif
  398. #define    SET_DMA_ADDR(regsPtr, value)    {\
  399.         (regsPtr)->dmaAddressLow = ((unsigned) (value) & 0xffff);          \
  400.         (regsPtr)->dmaAddressHigh = (((unsigned)(value) >> 16) & 0xffff); \
  401.     }
  402. #define    READ_DMA_ADDR(regsPtr)    \
  403.         (((regsPtr)->dmaAddressHigh << 16) | ((regsPtr)->dmaAddressLow))
  404.  
  405. /*
  406.  * Status Register.
  407.  * Note:
  408.  *    (r)    indicates bit is read only.
  409.  *    (rw)    indicates bit is read or write.
  410.  *    (v)    vme host adaptor interface only.
  411.  *    (o)    sun3/50 onboard host adaptor interface only.
  412.  *    (b)    both vme and sun3/50 host adaptor interfaces.
  413.  */
  414. #define SI_CSR_DMA_ACTIVE    0x8000    /* (r,o) dma transfer active */
  415. #define SI_CSR_DMA_CONFLICT    0x4000    /* (r,b) reg accessed while dmaing */
  416. #define SI_CSR_DMA_BUS_ERR    0x2000    /* (r,b) bus error during dma */
  417. #define SI_CSR_ID        0x1000    /* (r,b) 0 for 3/50, 1 for SCSI-3, */
  418.                     /* 0 if SCSI-3 unmodified */
  419. #define SI_CSR_FIFO_FULL    0x0800    /* (r,b) fifo full */
  420. #define SI_CSR_FIFO_EMPTY    0x0400    /* (r,b) fifo empty */
  421. #define SI_CSR_SBC_IP        0x0200    /* (r,b) sbc interrupt pending */
  422. #define SI_CSR_DMA_IP        0x0100    /* (r,b) dma interrupt pending */
  423. #define SI_CSR_LOB        0x00c0    /* (r,v) number of leftover bytes */
  424. #define SI_CSR_LOB_THREE    0x00c0    /* (r,v) three leftover bytes */
  425. #define SI_CSR_LOB_TWO        0x0080    /* (r,v) two leftover bytes */
  426. #define SI_CSR_LOB_ONE        0x0040    /* (r,v) one leftover byte */
  427. #define SI_CSR_BPCON        0x0020    /* (rw,v) byte packing control */
  428.                     /* dma is in 0=longwords, 1=words */
  429. #define SI_CSR_DMA_EN        0x0010    /* (rw,v) dma enable */
  430. #define SI_CSR_SEND        0x0008    /* (rw,b) dma dir, 1=to device */
  431. #define SI_CSR_INTR_EN        0x0004    /* (rw,b) interrupts enable */
  432. #define SI_CSR_FIFO_RES        0x0002    /* (rw,b) inits fifo, 0=reset */
  433. #define SI_CSR_SCSI_RES        0x0001    /* (rw,b) reset sbc and udc, 0=reset */
  434.  
  435.  
  436. /*
  437.  * devSCSI3Debug - debugging level
  438.  *    2 - normal level
  439.  *    4 - one print per command in the normal case
  440.  *    5 - traces interrupts
  441.  */
  442. int devSCSI3Debug = 2;
  443.  
  444. /*
  445.  * Number of times to try things like target selection.
  446.  */
  447. #define SBC_NUM_RETRIES 3
  448.  
  449. /*
  450.  * Registers are passed into the wait routine as Addresses, and their
  451.  * size is passed in as a separate argument to determine type coercion.
  452.  */
  453. typedef enum {
  454.     REG_BYTE,
  455.     REG_SHORT
  456. } RegType;
  457.  
  458. /*
  459.  * For waiting, there are several possibilities:
  460.  *  ACTIVE_HIGH - wait for any bits in mask to be 1
  461.  *  ACTIVE_ALL  - wait for all bits in mask to be 1
  462.  *  ACTIVE_LOW  - wait for any bits in mask to be 0.
  463.  *  ACTIVE_NONE - wait for all bits in mask to be 0.
  464.  */
  465. typedef enum {
  466.     ACTIVE_HIGH,
  467.     ACTIVE_ALL,
  468.     ACTIVE_LOW,
  469.     ACTIVE_NONE,
  470. } BitSelection;        
  471.  
  472. /* Forward declaration. */
  473. typedef struct Controller Controller;
  474.  
  475. /*
  476.  * Device - The data structure containing information about a device. One of
  477.  * these structure is kept for each attached device. Note that is structure
  478.  * is casted into a ScsiDevice and returned to higher level software.
  479.  * This implies that the ScsiDevice must be the first field in this
  480.  * structure.
  481.  */
  482.  
  483. typedef struct Device {
  484.     ScsiDevice handle;    /* Scsi Device handle. This is the only part
  485.              * of this structure visible to higher 
  486.              * level software. MUST BE FIRST FIELD IN STRUCTURE.
  487.              */
  488.     int    targetID;    /* SCSI Target ID of this device. Note that
  489.              * the LUN is store in the device handle.  */
  490.     Controller *ctrlPtr;    /* Controller to which device is attached. */
  491.            /*
  492.             * The following part of this structure is 
  493.             * used to handle SCSI commands that return 
  494.             * CHECK status. To handle the REQUEST SENSE
  495.             * command we must: 1) Save the state of the current
  496.             * command into the "struct FrozenCommand". 2) Submit
  497.             * a request sense command formatted in SenseCmd
  498.             * to the device.  */
  499.     struct FrozenCommand {               
  500.     ScsiCmd    *scsiCmdPtr;       /* The frozen command. */
  501.     unsigned char statusByte; /* It's SCSI status byte, Will always have
  502.                    * the check bit set.
  503.                    */
  504.     int amountTransferred;    /* Number of bytes transferred by this 
  505.                    * command.
  506.                    */
  507.     } frozen;    
  508.     char senseBuffer[DEV_MAX_SENSE_BYTES]; /* Data buffer for request sense */
  509.     ScsiCmd        SenseCmd;         /* Request sense command buffer. */
  510. } Device;
  511.  
  512. /*
  513.  * Controller - The Data structure describing a sun SCSI3 controller. One
  514.  * of these structures exists for each active SCSI3 HBA on the system. Each
  515.  * controller may have from zero to 56 (7 targets each with 8 logical units)
  516.  * devices attached to it. 
  517.  */
  518. struct Controller {
  519.     volatile CtrlRegs *regsPtr; /* Pointer to the registers of
  520.                                     this controller. */
  521.     Boolean  onBoard;    /* TRUE if this is a on board version of the 
  522.              * controller such as in the Sun 3/50, 3/60. FALSE
  523.              * if it is the VME version.
  524.              */
  525.     UDCDMAtable    *udcDmaTable; /* Table for the onBoard's DMA chip. */
  526.     int        dmaState;    /* DMA state for this controller, defined below. */
  527.     Boolean dmaSetup;    /* TRUE if the DMA register have been setup. Only used
  528.              * for the VME version. */
  529.     char    *name;    /* String for error message for this controller.  */
  530.     DevCtrlQueues devQueues;    /* Device queues for devices attached to this
  531.                  * controller.     */
  532.     Sync_Semaphore mutex; /* Lock protecting controller's data structures. */
  533.               /* Until disconnect/reconnect is added we can have
  534.                * only one current active device and scsi command.*/
  535.     Device     *devPtr;       /* Current active command. */
  536.     ScsiCmd   *scsiCmdPtr; /* Current active command. */
  537.     Address    dmaBuffer; /* DMA buffer allocated for this address. */
  538.     Device  *devicePtr[8][8]; /* Pointers to the device attached to the 
  539.                    * controller index by [targetID][LUN].
  540.                    * NIL if device not attached yet. Zero if
  541.                    * device conflicts with HBA address.  */
  542. };
  543.  
  544. /*
  545.  * Possible values for the dmaState state field of a controller.
  546.  *
  547.  * DMA_RECEIVE  - data is being received from the device, such as on
  548.  *    a read, inquiry, or request sense.
  549.  * DMA_SEND     - data is being send to the device, such as on a write.
  550.  * DMA_INACTIVE - no data needs to be transferred.
  551.  */
  552.  
  553. #define DMA_RECEIVE  0x0
  554. #define    DMA_SEND     0x2
  555. #define    DMA_INACTIVE 0x4
  556.  
  557. /*
  558.  * Test, mark, and unmark the controller as busy.
  559.  */
  560. #define    IS_CTRL_BUSY(ctrlPtr)    ((ctrlPtr)->scsiCmdPtr != (ScsiCmd *) NIL)
  561. #define    SET_CTRL_BUSY(ctrlPtr,scsiCmdPtr) \
  562.         ((ctrlPtr)->scsiCmdPtr = (scsiCmdPtr))
  563. #define    SET_CTRL_FREE(ctrlPtr)    ((ctrlPtr)->scsiCmdPtr = (ScsiCmd *) NIL)
  564.  
  565. /*
  566.  * MAX_SCSI3_CTRLS - Maximum number of SCSI3 controllers attached to the
  567.  *             system. We set this to the maximum number of VME slots
  568.  *             in any Sun system currently available.
  569.  */
  570. #define    MAX_SCSI3_CTRLS    16
  571. static Controller *Controllers[MAX_SCSI3_CTRLS];
  572. /*
  573.  * Highest number controller we have probed for.
  574.  */
  575. static int numSCSI3Controllers = 0;
  576.  
  577. /*
  578.  * Forward declarations.  
  579.  */
  580.  
  581. static Boolean          ProbeOnBoard _ARGS_ ((int address));
  582. static void             Reset _ARGS_ ((Controller *ctrlPtr));
  583. static ReturnStatus     SendCommand _ARGS_ ((Device *devPtr,
  584.                                              ScsiCmd *scsiCmdPtr));
  585. static ReturnStatus     GetStatusByte _ARGS_ ((Controller *ctrlPtr,
  586.                                                unsigned char *statusBytePtr));
  587. static ReturnStatus     WaitPhase _ARGS_ ((Controller *ctrlPtr,
  588.                                            unsigned int phase, Boolean reset));
  589. static ReturnStatus     WaitReg _ARGS_ ((Controller *ctrlPtr,
  590.                                          Address thisRegPtr, RegType type,
  591.                      unsigned int conditions,
  592.                      Boolean reset, BitSelection bitSel));
  593. static ReturnStatus     GetByte _ARGS_ ((Controller *ctrlPtr,
  594.                                          unsigned int phase, char *charPtr));
  595. #ifdef reselection
  596. static ReturnStatus     PutByte _ARGS_ ((Controller *ctrlPtr, char *dataPtr));
  597. #endif
  598. static void             PrintRegs _ARGS_((volatile CtrlRegs *regsPtr));
  599. static void             StartDMA _ARGS_ ((Controller *ctrlPtr));
  600.  
  601.  
  602. /*
  603.  *----------------------------------------------------------------------
  604.  *
  605.  * ProbeOnBoard --
  606.  *
  607.  *    Test of the existance for the onboard SCSI-3 interface.
  608.  *
  609.  * Results:
  610.  *    TRUE if the host adaptor was found.
  611.  *
  612.  * Side effects:
  613.  *    None.
  614.  *
  615.  *----------------------------------------------------------------------
  616.  */
  617. static Boolean
  618. ProbeOnBoard(address)
  619.     int address;            /* Alledged controller address */
  620. {
  621.     ReturnStatus    status;
  622.     register volatile CtrlRegs *regsPtr = (volatile CtrlRegs *)address;
  623.     int x;
  624.  
  625.     /*
  626.      * Touch the device's UDC read data register.
  627.      */
  628.     status = Mach_Probe(sizeof(regsPtr->udcRdata),(char *)&(regsPtr->udcRdata),
  629.             (char *)&x);
  630.     if (status != SUCCESS) {
  631.     if (devSCSI3Debug > 3) {
  632.         printf("Onboard SCSI3 not found at address 0x%x\n",address);
  633.     }
  634.         return (FALSE);
  635.     }
  636.     if (devSCSI3Debug > 3) {
  637.     printf("Onboard SCSI3 found\n");
  638.     }
  639.     return(TRUE);
  640. }
  641.  
  642. /*
  643.  *----------------------------------------------------------------------
  644.  *
  645.  * ProbeVME --
  646.  *
  647.  *    Probe memory for the new-style VME SCSI interface.  This occupies
  648.  *    2K of VME space.
  649.  *
  650.  * Results:
  651.  *    TRUE if the host adaptor was found.
  652.  *
  653.  * Side effects:
  654.  *    None.
  655.  *
  656.  *----------------------------------------------------------------------
  657.  */
  658. static Boolean
  659. ProbeVME(address)
  660.     int address;            /* Alledged controller address */
  661. {
  662.     volatile CtrlRegs *regsPtr = (volatile CtrlRegs *)address;
  663.     ReturnStatus    status;
  664.  
  665.     /*
  666.      * Touch the device. The dmaCount register should hold more
  667.      * than 16 bits, which is all the old host adaptor's dmaCount can hold.
  668.      */
  669.     { 
  670.     unsigned short value = 0xABCC;
  671.     status = Mach_Probe(sizeof(regsPtr->dmaCountLow), (char *) &value,
  672.             (char *) &(regsPtr->dmaCountLow));
  673.     value = 0x4A;
  674.     status = Mach_Probe(sizeof(regsPtr->dmaCountHigh),
  675.                (char *) &value, (char *) &(regsPtr->dmaCountHigh));
  676.   }
  677.     if (status != SUCCESS) {
  678.     return (FALSE);
  679.     }
  680.     if (regsPtr->dmaCountLow != 0xABCC) {
  681.      printf("Warning: ProbeSCSI-3 read back problem %x not %x\n",
  682.         READ_DMA_COUNT(regsPtr), 0xABCC);
  683.     return (FALSE);
  684.     } 
  685.  
  686.     if (devSCSI3Debug > 3) {
  687.     printf("VME SCSI3 found\n");
  688.     }
  689.     return(TRUE);
  690. }
  691.  
  692.  
  693. /*
  694.  *----------------------------------------------------------------------
  695.  *
  696.  * Reset --
  697.  *
  698.  *    Reset a SCSI bus controlled by the SCSI-3 Sun Host Adaptor.
  699.  *
  700.  * Results:
  701.  *    None.
  702.  *
  703.  * Side effects:
  704.  *    Reset the controller and SCSI bus.
  705.  *
  706.  *----------------------------------------------------------------------
  707.  */
  708. static void
  709. Reset(ctrlPtr)
  710.     Controller *ctrlPtr;
  711. {
  712.     volatile CtrlRegs *regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  713.     unsigned char clear;
  714.  
  715.     SET_FIFO_COUNT(regsPtr,0);
  716.     regsPtr->control = 0;
  717.     MACH_DELAY(100);
  718.     regsPtr->control = SI_CSR_SCSI_RES | SI_CSR_FIFO_RES;
  719.  
  720.     if (!ctrlPtr->onBoard) {
  721.     SET_DMA_COUNT(regsPtr,0);
  722.     SET_DMA_ADDR(regsPtr,0);
  723.     }
  724.  
  725.     regsPtr->sbc.write.initCmd = SBC_ICR_RST;
  726.     MACH_DELAY(1000);
  727.     regsPtr->sbc.write.initCmd = 0;
  728.     
  729.     clear = regsPtr->sbc.read.clear;
  730. #ifdef lint
  731.     regsPtr->sbc.read.clear = clear;
  732. #endif
  733.     regsPtr->control |= SI_CSR_INTR_EN;
  734.     regsPtr->sbc.write.mode = 0;
  735. }
  736.  
  737.  
  738. /*
  739.  *----------------------------------------------------------------------
  740.  *
  741.  * SendCommand --
  742.  *
  743.  *      Send a command to a SCSI controller via the SCSI-3 Host Adaptor.
  744.  *    NOTE: The caller is assumed to have the master lock of the controller
  745.  *    to which the device is attached held.
  746.  *      
  747.  *
  748.  * Results:
  749.  *    An error code.
  750.  *
  751.  * Side effects:
  752.  *    Those of the command (Read, write etc.)
  753.  *
  754.  *----------------------------------------------------------------------
  755.  */
  756. static Address lastDmaAddr;
  757.  
  758. static ReturnStatus
  759. SendCommand(devPtr, scsiCmdPtr)
  760.     Device     *devPtr;        /* Device to sent to. */
  761.     ScsiCmd    *scsiCmdPtr;        /* Command to send. */
  762. {
  763.     ReturnStatus status;
  764.     register volatile CtrlRegs *regsPtr; /* Host Adaptor registers */
  765.     register volatile unsigned char *initCmdPtr; /* pointer to initCmd reg */
  766.     register volatile unsigned char *modePtr; /* pointer to mode register */
  767.     register char *charPtr;
  768.     Controller    *ctrlPtr;
  769.     int i, numAttempts;
  770.     int size;                /* Number of bytes to transfer */
  771.     Address addr;            /* Kernel address of transfer */
  772.  
  773.     /*
  774.      * Set current active device and command for this controller.
  775.      */
  776.     ctrlPtr = devPtr->ctrlPtr;
  777.     SET_CTRL_BUSY(ctrlPtr,scsiCmdPtr);
  778.     ctrlPtr->dmaBuffer = (Address) NIL;
  779.     ctrlPtr->devPtr = devPtr;
  780.     size = scsiCmdPtr->bufferLen;
  781.     addr = scsiCmdPtr->buffer;
  782.     /*
  783.      * Determine the DMA state the size and direction of data transfer.
  784.      */
  785.     if (size == 0) {
  786.     ctrlPtr->dmaState = DMA_INACTIVE;
  787.     } else {
  788.     ctrlPtr->dmaState = (scsiCmdPtr->dataToDevice) ? DMA_SEND :
  789.                              DMA_RECEIVE;
  790.     }
  791.     ctrlPtr->dmaSetup = FALSE;
  792.     if (devSCSI3Debug > 3) {
  793.     printf("SCSI3Command: %s addr %x size %d dma %s\n",
  794.         devPtr->handle.locationName, addr, size,
  795.         (ctrlPtr->dmaState == DMA_INACTIVE) ? "not active" :
  796.         ((ctrlPtr->dmaState == DMA_SEND) ? "send" :
  797.                               "receive"));
  798.     }
  799.  
  800.     regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  801.     initCmdPtr = ®sPtr->sbc.write.initCmd;
  802.     modePtr = ®sPtr->sbc.write.mode;
  803.     /*
  804.      * Clear all control lines.
  805.      */
  806.     if (!ctrlPtr->onBoard) {
  807.     /*
  808.      * For VME interface dis-allow DMA interrupts from reconnect attempts.
  809.      */
  810.     regsPtr->control &= ~SI_CSR_DMA_EN;
  811.     regsPtr->control |= SI_CSR_BPCON;    /* word byte packing */
  812.     }
  813.     regsPtr->sbc.write.select = 0;
  814.     regsPtr->sbc.write.trgtCmd = 0;
  815.     regsPtr->sbc.write.initCmd = 0;
  816.     *modePtr &= ~SBC_MR_DMA;
  817.  
  818.     /*
  819.      * SCSI ARBITRATION.
  820.      *
  821.      * Arbitrate for the SCSI bus by putting our SCSI ID on the data
  822.      * bus and asserting the BUSY signal.  After an arbitration delay
  823.      * we look for other, higher priority IDs on the bus. (We won't find
  824.      * any because the Host Adaptor is wired in to be the highest.)
  825.      * Arbitration is completed by asserting the SELECT line.
  826.      */
  827.  
  828.     regsPtr->sbc.write.data = SI_HOST_ID;
  829.     for (numAttempts = 0; numAttempts < SBC_NUM_RETRIES; numAttempts++) {
  830.     /*
  831.      * Wait for the bus to go to BUS FREE - busy line not held.
  832.      */
  833.     for (i=0 ; i < (WAIT_LENGTH/10) ; i++) {
  834.         if ((regsPtr->sbc.read.curStatus & SBC_CBSR_BSY) == 0) {
  835.         break;
  836.         } else {
  837.         MACH_DELAY(10);
  838.         }
  839.     }
  840.     if (i == (WAIT_LENGTH/10)) {
  841.         /*
  842.          * Probably a higher level synchronization error.  The
  843.          * SCSI bus is probably busy with another transaction.
  844.          */
  845.         printf("Warning: %s SCSI bus stuck busy\n",ctrlPtr->name);
  846.         Reset(ctrlPtr);
  847.         return(FAILURE);
  848.     }
  849.     /*
  850.      * Enter Arbitration mode on the chip.
  851.      */
  852.     *modePtr |= SBC_MR_ARB;
  853.     status = WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.initCmd,
  854.                    REG_BYTE, SBC_ICR_AIP, NO_RESET, ACTIVE_HIGH);
  855.     if (status == DEV_TIMEOUT) {
  856.         continue;
  857.     }
  858.     if (status != SUCCESS) {
  859.         regsPtr->sbc.write.data = 0;
  860.         *modePtr &= ~SBC_MR_ARB;
  861.         printf("Warning: %s arbitration failed on %s\n", 
  862.                 ctrlPtr->name, devPtr->handle.locationName);
  863.         return(status);
  864.     }
  865.     MACH_DELAY(SI_ARBITRATION_DELAY);
  866.     if (((regsPtr->sbc.read.initCmd & SBC_ICR_LA) == 0) &&
  867.         ((regsPtr->sbc.read.data & ~SI_HOST_ID)  < SI_HOST_ID)) {
  868.         break;
  869.     }
  870.     /*
  871.      * Lost arbitration due to reselection attempt by a target.
  872.      */
  873.     *modePtr &= ~SBC_MR_ARB;
  874.     printf("Warning: %s lost arbitration\n",ctrlPtr->name);
  875.     /*
  876.      * A target may have tried to select us during arbitration phase.
  877.      * At this point we should save the current command and
  878.      * respond to the reconnection interrupt.
  879.      */
  880.     if ((regsPtr->sbc.read.curStatus & SBC_CBSR_SEL) && 
  881.         (regsPtr->sbc.read.curStatus & SBC_CBSR_IO) &&
  882.         (regsPtr->sbc.read.data & SI_HOST_ID)) {
  883.         printf("Warning: %s someone attempted to reselect.\n",ctrlPtr->name);
  884.         return(FAILURE);
  885.     }
  886.     }
  887.     if (numAttempts == SBC_NUM_RETRIES) {
  888.     Reset(ctrlPtr);
  889.     printf("Warning: %s unable to select target %s\n", ctrlPtr->name,
  890.                 devPtr->handle.locationName);
  891.     return(FAILURE);    
  892.     }
  893.  
  894.     /*
  895.      * Arbitration complete.  Confirm by setting SELECT and BUSY.
  896.      * The ATN (attention) line would be set here if we want allow
  897.      * disconnection by the target.
  898.      */
  899.     *initCmdPtr = SBC_ICR_SEL | SBC_ICR_BUSY;
  900.     *modePtr &= ~SBC_MR_ARB;
  901.     MACH_DELAY(SI_BUS_CLEAR_DELAY + SI_BUS_SETTLE_DELAY);
  902.     /*
  903.      * SCSI SELECTION.
  904.      *
  905.      * Select the target by putting its ID plus our own on the bus
  906.      * and waiting for the target to assert the BUSY signal.  We
  907.      * drop SEL and DATA after the target responds.
  908.      */
  909.     regsPtr->sbc.write.data = (1 << devPtr->targetID) | SI_HOST_ID;
  910.     *initCmdPtr = SBC_ICR_SEL | SBC_ICR_DATA | SBC_ICR_BUSY;
  911.     MACH_DELAY(1);
  912.     *initCmdPtr  &= ~SBC_ICR_BUSY;
  913.     status = WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.curStatus,
  914.                REG_BYTE, SBC_CBSR_BSY, RESET, ACTIVE_HIGH);
  915.     if (status != SUCCESS) {
  916.     printf("Warning: %s can't select %s\n", 
  917.             ctrlPtr->name, devPtr->handle.locationName);
  918.     regsPtr->sbc.write.data = 0;
  919.     return(status);
  920.     }
  921.     *initCmdPtr &= ~(SBC_ICR_SEL | SBC_ICR_DATA);
  922.     /*
  923.      * Clear selection and DMA interrupts.
  924.      */
  925.     regsPtr->sbc.write.select = 0;
  926.     *modePtr &= ~SBC_MR_DMA;
  927.  
  928. #ifdef reselection
  929.     /*
  930.      * After target selection there is an optional message phase where
  931.      * we send an IDENTIFY message to indicate dis-connect capability.
  932.      */
  933.     data = SCSI_IDENDIFY | devPtr->handle.LUN;
  934.     status = PutByte(ctrlPtr, &data);
  935.     if (status != SUCCESS) {
  936.     return(status);
  937.     }
  938. #endif reselection
  939. #ifdef lint
  940.     status = PutByte(ctrlPtr, (char *) 0);
  941. #endif
  942.     if (ctrlPtr->dmaState != DMA_INACTIVE) {
  943.     if ((unsigned) scsiCmdPtr->buffer < (unsigned) VMMACH_DMA_START_ADDR) {
  944.         ctrlPtr->dmaBuffer = addr = 
  945.             VmMach_DMAAlloc(size,scsiCmdPtr->buffer);
  946.         if (addr == (Address) NIL) {
  947.         panic("SendCommand: unable to allocate DMA memory.");
  948.         }
  949.         lastDmaAddr = ctrlPtr->dmaBuffer;    /* XXX */
  950.     } else {
  951.         /*
  952.          * Already mapped into DMA space.
  953.          */
  954.         addr = scsiCmdPtr->buffer;
  955.     }
  956.     if (devSCSI3Debug > 5) {
  957.         printf("SCSI3Command: selected %s setup DMA addr 0x%x size %d\n",
  958.         devPtr->handle.locationName, addr, size);
  959.     }
  960.     if (addr == (Address) NIL) {
  961.         panic("%s can't allocate DMA buffer of %d bytes\n", 
  962.             devPtr->handle.locationName, size);
  963.     }
  964.     /*
  965.      * DMA SETUP.
  966.      *
  967.      * First reset the DMA controllers so they
  968.      * don't complain with a DMA_CONFLICT interrupt.
  969.      */
  970.     if (ctrlPtr->onBoard) {
  971.         MACH_DELAY(SI_UDC_WAIT);
  972.         regsPtr->udcRaddr = UDC_ADR_COMMAND;
  973.         MACH_DELAY(SI_UDC_WAIT);
  974.         regsPtr->udcRdata = UDC_CMD_RESET;
  975.         MACH_DELAY(SI_UDC_WAIT);
  976.     } 
  977.  
  978.     regsPtr->control &= ~SI_CSR_FIFO_RES;    
  979.     regsPtr->control |= SI_CSR_FIFO_RES;    
  980.     if (ctrlPtr->dmaState == DMA_RECEIVE) {
  981.         regsPtr->control &= ~SI_CSR_SEND;
  982.     } else {
  983.         regsPtr->control |= SI_CSR_SEND;
  984.     }
  985.     if (ctrlPtr->onBoard) {
  986.         register UDCDMAtable *udct = ctrlPtr->udcDmaTable;
  987.         if (devSCSI3Debug > 4) {
  988.         printf("SCSI DMA addr = 0x%x size = %d\n",addr,size);
  989.         }
  990.         /*
  991.          * Set fifoCount which is also wired to dmaCount, thus
  992.          * both registers are set.  The onboard DMA controller requires
  993.          * that these counts be set before entering the DATA PHASE.
  994.          */
  995.          regsPtr->fifoCountLow = size;
  996.  
  997.         /*
  998.          * Go through reset again becuase of the bug on the 3/50
  999.          * where bytes occasionally linger in the DMA fifo.
  1000.          */
  1001.         MACH_DELAY(SI_UDC_WAIT);
  1002.         regsPtr->udcRaddr = UDC_ADR_COMMAND;
  1003.         MACH_DELAY(SI_UDC_WAIT);
  1004.         regsPtr->udcRdata = UDC_CMD_RESET;
  1005.         MACH_DELAY(SI_UDC_WAIT);
  1006.         regsPtr->control &= ~SI_CSR_FIFO_RES;    
  1007.         regsPtr->control |= SI_CSR_FIFO_RES;
  1008.         /*
  1009.          * End extra reset code.  This is really needed on the 3/50.
  1010.          */
  1011.  
  1012.         /*
  1013.          * The onboard DMA controller expects a control block (!)
  1014.          * that describes the DMA transfer.
  1015.          */
  1016.         udct->haddr = (((unsigned) addr & 0xff0000) >> 8) | UDC_ADDR_INFO;
  1017.         udct->laddr = (unsigned)addr & 0xffff;
  1018.         udct->hcmr = UDC_CMR_HIGH;
  1019.         udct->count = size / 2; /* #bytes -> #words */
  1020.  
  1021.         if (ctrlPtr->dmaState == DMA_RECEIVE) {
  1022.             udct->rsel = UDC_RSEL_RECV;
  1023.             udct->lcmr = UDC_CMR_LRECV;
  1024.         } else {
  1025.             udct->rsel = UDC_RSEL_SEND;
  1026.             udct->lcmr = UDC_CMR_LSEND;
  1027.             if (size & 1) {
  1028.                 udct->count++;
  1029.             }
  1030.         }
  1031.         /*
  1032.          * Now we tell the DMA chip where the control block is
  1033.          * by setting the Chain Address Register (CAR).
  1034.          */
  1035.         regsPtr->udcRaddr = UDC_ADR_CAR_HIGH;
  1036.         MACH_DELAY(SI_UDC_WAIT);
  1037.         regsPtr->udcRdata = ((int)udct & 0xff0000) >> 8;
  1038.         MACH_DELAY(SI_UDC_WAIT);
  1039.         regsPtr->udcRaddr = UDC_ADR_CAR_LOW;
  1040.         MACH_DELAY(SI_UDC_WAIT);
  1041.         regsPtr->udcRdata = (int)udct & 0xffff;
  1042.         /*
  1043.          * Tell the chip to be a DMA master.
  1044.          */
  1045.         MACH_DELAY(SI_UDC_WAIT);
  1046.         regsPtr->udcRaddr = UDC_ADR_MODE;
  1047.         MACH_DELAY(SI_UDC_WAIT);
  1048.         regsPtr->udcRdata = UDC_MODE;
  1049.         /*
  1050.          * Tell the chip to interrupt on error.
  1051.          */
  1052.         MACH_DELAY(SI_UDC_WAIT);
  1053.         regsPtr->udcRaddr = UDC_ADR_COMMAND;
  1054.         MACH_DELAY(SI_UDC_WAIT);
  1055.         regsPtr->udcRdata = UDC_CMD_CIE;
  1056.  
  1057.     } else {
  1058.         /*
  1059.          * Clear thing now, and set size later in StartDMA.
  1060.          */
  1061.         SET_FIFO_COUNT(regsPtr,0); 
  1062.         SET_DMA_COUNT(regsPtr,0);
  1063.         if (ctrlPtr->dmaState != DMA_INACTIVE) {
  1064.         SET_DMA_ADDR(regsPtr,(unsigned)(addr - VMMACH_DMA_START_ADDR));
  1065.         } else {
  1066.         SET_DMA_ADDR(regsPtr,0);
  1067.         }
  1068.     }
  1069.     } else {
  1070.     /*
  1071.      * fifoCount register is wired to dmaCount so both are set.
  1072.      */
  1073.     SET_FIFO_COUNT(regsPtr,0);
  1074.     }
  1075.     regsPtr->control |= SI_CSR_INTR_EN;
  1076.  
  1077.     if (devSCSI3Debug > 5) {
  1078.     printf("SCSI3Command: %s waiting for command phase.\n",
  1079.         devPtr->handle.locationName);
  1080.     }
  1081.     status = WaitPhase(ctrlPtr, PHASE_COMMAND, RESET);
  1082.     if (status != SUCCESS) {
  1083.     /*
  1084.      * After we implement reselection it is at this point that
  1085.      * we have to handle messages from targets.
  1086.      */
  1087.     if (devSCSI3Debug > 0) {
  1088.         printf("SCSI3: wait on PHASE_COMMAND failed.\n");
  1089.     }
  1090.     return(status);
  1091.     }
  1092.     /*
  1093.      * Stuff the control block through the commandStatus register.
  1094.      * The handshake on the SCSI bus is visible here:  we have to
  1095.      * wait for the Request line on the SCSI bus to be raised before
  1096.      * we can send the next command byte to the controller.  Then we
  1097.      * have to set the ACK line after putting out the data, and finnaly
  1098.      * wait for the REQ line to drop again.
  1099.      */
  1100.     if (devSCSI3Debug > 5) {
  1101.     printf("SCSI3Command: %s stuffing command of %d bytes.\n", 
  1102.         devPtr->handle.locationName, scsiCmdPtr->commandBlockLen);
  1103.     }
  1104.     regsPtr->sbc.write.trgtCmd = TCR_COMMAND;
  1105.     charPtr = scsiCmdPtr->commandBlock;
  1106.     for (i=0 ; i< scsiCmdPtr->commandBlockLen; i++) {
  1107.     /*
  1108.      * SCSI DATA TRANSFER HANDSHAKE.
  1109.      *
  1110.      * Wait for Target to request data byte.
  1111.      */
  1112.     status = WaitReg(ctrlPtr, (Address)®sPtr->sbc.read.curStatus,
  1113.                    REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_HIGH);
  1114.     if (status != SUCCESS) {
  1115.         printf("Warning: %s couldn't send SCSI command block byte %d\n",
  1116.                  ctrlPtr->name, i);
  1117.         return(status);
  1118.     }
  1119.     /*
  1120.      * Gate data onto SCSI bus and then set ACK.
  1121.      */
  1122.     regsPtr->sbc.write.data = *charPtr;
  1123.     regsPtr->sbc.write.initCmd = SBC_ICR_DATA;
  1124.     regsPtr->sbc.write.initCmd |= SBC_ICR_ACK;
  1125.     /*
  1126.      * Wait for Target to take byte and drop REQ.
  1127.      */
  1128.     status = WaitReg(ctrlPtr, (Address)®sPtr->sbc.read.curStatus,
  1129.                    REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_LOW);
  1130.     if (status != SUCCESS) {
  1131.         printf("Warning: %s: request line didn't go low.\n",
  1132.                  ctrlPtr->name);
  1133.         return(status);
  1134.     }
  1135.     if (devSCSI3Debug > 5) {
  1136.         printf("0x%x ", *charPtr);
  1137.     }
  1138.     charPtr++;
  1139.     if (i < scsiCmdPtr->commandBlockLen - 1) {
  1140.         /*
  1141.          * Finally we drop the ACK line.
  1142.          */
  1143.         regsPtr->sbc.write.initCmd = 0;
  1144.     }
  1145.     }
  1146.     if (devSCSI3Debug > 5) {
  1147.     printf("\n");
  1148.     }
  1149.  
  1150.     i = regsPtr->sbc.read.clear;
  1151.     regsPtr->sbc.write.select = SI_HOST_ID;
  1152.     regsPtr->sbc.write.trgtCmd = TCR_UNSPECIFIED;
  1153.     *modePtr |= SBC_MR_DMA;
  1154.     regsPtr->sbc.write.initCmd = 0;
  1155.     if (!ctrlPtr->onBoard) {
  1156.     regsPtr->control |= SI_CSR_DMA_EN;
  1157.     }
  1158.     status = SUCCESS;
  1159.     return(status);
  1160. }
  1161.  
  1162.  
  1163. /*
  1164.  *----------------------------------------------------------------------
  1165.  *
  1166.  * StartDMA --
  1167.  *
  1168.  *    Issue the sequence of commands to the controller to start DMA.
  1169.  *    This can be called by Dev_SCSI3Intr in response to a DATA_{IN,OUT}
  1170.  *    phase message.
  1171.  *
  1172.  * Results:
  1173.  *    None.
  1174.  *
  1175.  * Side effects:
  1176.  *    DMA is enabled.  No registers other than the control register are
  1177.  *    to be accessed until DMA is disabled again.
  1178.  *
  1179.  *----------------------------------------------------------------------
  1180.  */
  1181. static void
  1182. StartDMA(ctrlPtr)
  1183.     register Controller *ctrlPtr;
  1184. {
  1185.     register volatile CtrlRegs *regsPtr;
  1186.     unsigned char junk;
  1187.     int    size;
  1188.  
  1189.     size = ctrlPtr->scsiCmdPtr->bufferLen;
  1190.  
  1191.     if (devSCSI3Debug > 4) {
  1192.     printf("%s: StartDMA %s called size = %d.\n", ctrlPtr->name,
  1193.         (ctrlPtr->dmaState == DMA_RECEIVE) ? "receive" :
  1194.         ((ctrlPtr->dmaState == DMA_SEND) ? "send" :
  1195.                           "not-active!"), size);
  1196.     }
  1197.     regsPtr = ctrlPtr->regsPtr;
  1198.     if (ctrlPtr->onBoard) {
  1199.     /*
  1200.      * The DMA control block has already been set up.  We just say "go".
  1201.      */
  1202.     MACH_DELAY(SI_UDC_WAIT);
  1203.     regsPtr->udcRdata = UDC_CMD_STRT_CHN;
  1204.     } else {
  1205.         SET_DMA_COUNT(regsPtr,size);
  1206.     ctrlPtr->dmaSetup = TRUE;
  1207.     }
  1208.  
  1209.     if (ctrlPtr->dmaState == DMA_RECEIVE) {
  1210.     regsPtr->sbc.write.trgtCmd = TCR_DATA_IN;
  1211.     junk = regsPtr->sbc.read.clear;
  1212.     regsPtr->sbc.write.mode |= SBC_MR_DMA;
  1213.     regsPtr->sbc.write.initRecv = 0;
  1214.     } else {
  1215.     regsPtr->sbc.write.trgtCmd = TCR_DATA_OUT;
  1216.     junk = regsPtr->sbc.read.clear;
  1217. #ifdef lint
  1218.     regsPtr->sbc.read.clear = junk;
  1219. #endif
  1220.     regsPtr->sbc.write.initCmd = SBC_ICR_DATA;
  1221.     regsPtr->sbc.write.mode |= SBC_MR_DMA;
  1222.     regsPtr->sbc.write.send = 0;
  1223.     }
  1224.     if (!ctrlPtr->onBoard) {
  1225.     regsPtr->control |= SI_CSR_DMA_EN;
  1226.     }
  1227. }
  1228.  
  1229.  
  1230. /*
  1231.  *----------------------------------------------------------------------
  1232.  *
  1233.  * GetStatusByte --
  1234.  *
  1235.  *    Complete an SCSI command by getting the status bytes from
  1236.  *    the device and waiting for the ``command complete''
  1237.  *    message that follows the status bytes.  
  1238.  *
  1239.  * Results:
  1240.  *    An error code if the status didn't come through or it
  1241.  *    indicated an error.
  1242.  *
  1243.  * Side effects:
  1244.  *    None.
  1245.  *
  1246.  *----------------------------------------------------------------------
  1247.  */
  1248. static ReturnStatus
  1249. GetStatusByte(ctrlPtr,statusBytePtr)
  1250.     Controller *ctrlPtr;        /* Controller to get byte from. */
  1251.     unsigned char *statusBytePtr;    /* Where to put the status byte. */
  1252. {
  1253.     register volatile CtrlRegs *regsPtr;
  1254.     ReturnStatus status;
  1255.     char message;
  1256.  
  1257.     if (devSCSI3Debug > 4) {
  1258.     printf("GetStatusByte called ");
  1259.     }
  1260.     regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  1261.     *statusBytePtr = 0;
  1262.  
  1263.     /*
  1264.      * After the DATA_IN/OUT phase we enter the STATUS phase for
  1265.      * 1 byte (usually) of status.  This is followed by the MESSAGE phase
  1266.      */
  1267.     status = WaitPhase(ctrlPtr, PHASE_STATUS, RESET);
  1268.     if (status != SUCCESS) {
  1269.     if (devSCSI3Debug > 3) {
  1270.         printf("Warning: %s wait on PHASE_STATUS failed.\n",ctrlPtr->name);
  1271.     }
  1272.     return(status);
  1273.     }
  1274.     /*
  1275.      * Get one status byte.
  1276.      */
  1277.     status = GetByte(ctrlPtr, PHASE_STATUS, (char *) statusBytePtr);
  1278.     if (status != SUCCESS) {
  1279.     printf("Warning: %s error 0x%x getting status byte\n", 
  1280.         ctrlPtr->name, status);
  1281.     return (status);
  1282.     }
  1283. #ifdef notdef
  1284.     /* 
  1285.      * From the way the code was originally written it looks like some
  1286.      * devices return more that one byte of status info. Since we don't
  1287.      * want these bytes drop them on the floor.
  1288.      */
  1289.     for (; ; ) {
  1290.         status = GetByte(ctrlPtr, PHASE_STATUS, (char *) statusBytePtr);
  1291.         if (devSCSI3Debug > 4 && (numStatusBytes == 0)) {
  1292.             printf("SCSI3-%d: got error %x after %d status bytes\n",
  1293.                  ctrlPtr->number, status, numStatusBytes);
  1294.         }
  1295.         break;
  1296.     }
  1297.         *statusBytePtr = statusByte;
  1298.         statusBytePtr++;
  1299.     }
  1300.     numStatusBytes++;
  1301.     }
  1302. #endif
  1303.     if (devSCSI3Debug > 4) {
  1304.     printf("got 0x%x\n", *statusBytePtr);
  1305.     }
  1306.     /*
  1307.      * Wait for the message in phase and grap the COMMAND COMPLETE message
  1308.      * off the bus.
  1309.      */
  1310.     status = WaitPhase(ctrlPtr, PHASE_MSG_IN, RESET);
  1311.     if (status != SUCCESS) {
  1312.         printf("Warning: %s wait on PHASE_MSG_IN after status failed.\n",
  1313.         ctrlPtr->name);
  1314.     return(status);
  1315.     } 
  1316.     status = GetByte(ctrlPtr, PHASE_MSG_IN, &message);
  1317.     if (status != SUCCESS) {
  1318.     printf("Warning: %s got error 0x%x getting message and status.\n",
  1319.                  ctrlPtr->name, status);
  1320.     return(status);
  1321.     }
  1322.     if (message != SCSI_COMMAND_COMPLETE) {
  1323.     printf("Warning: %s message %d after status is not command complete.\n",        ctrlPtr->name, message);
  1324.     return(FAILURE);
  1325.     }
  1326.     regsPtr->sbc.write.trgtCmd = TCR_UNSPECIFIED;
  1327.     if (devSCSI3Debug > 4) {
  1328.     printf("Got message 0x%x\n", message);
  1329.     }
  1330.     return(SUCCESS);
  1331. }
  1332.  
  1333.  
  1334. /*
  1335.  *----------------------------------------------------------------------
  1336.  *
  1337.  * WaitReg --
  1338.  *
  1339.  *    Wait for any of a set of bits to be enabled 
  1340.  *    in the specified register.  The generic regsPtr pointer is
  1341.  *    passed in so this routine can check for bus and parity errors.
  1342.  *    A pointer to the register to check, and an indicator of its type
  1343.  *    (its size) are passed in as well.  Finally, the conditions
  1344.  *     can be awaited to become 1 or 0.
  1345.  *
  1346.  * Results:
  1347.  *    SUCCESS if the condition occurred before a threshold time limit,
  1348.  *    DEV_TIMEOUT otherwise.
  1349.  *
  1350.  * Side effects:
  1351.  *    This resets the SCSI bus if the reset parameter is true and
  1352.  *    the condition bits are not set by the controller before timeout.
  1353.  *
  1354.  *----------------------------------------------------------------------
  1355.  */
  1356. static ReturnStatus
  1357. WaitReg(ctrlPtr, thisRegPtr, type, conditions, reset, bitSel)
  1358.     Controller *ctrlPtr;    /* Controller state */
  1359.     Address thisRegPtr;        /* pointer to register to check */
  1360.     RegType type;        /* "type" of the register */
  1361.     unsigned int conditions;    /* one or more bits to check */
  1362.     Boolean reset;        /* whether to reset the bus on error */
  1363.     BitSelection bitSel;    /* check for all or some bits going to 1/0 */
  1364. {
  1365.     volatile register CtrlRegs *regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  1366.     register int i;
  1367.     ReturnStatus status = DEV_TIMEOUT;
  1368.     register unsigned int thisReg;
  1369.  
  1370.     for (i=0 ; i<(WAIT_LENGTH/10) ; i++) {
  1371.     switch (type) {
  1372.         case REG_BYTE: {
  1373.         unsigned char *charPtr = (unsigned char *) thisRegPtr;
  1374.         thisReg = (unsigned int) *charPtr;
  1375.         break;
  1376.         }
  1377.         case REG_SHORT: {
  1378.         unsigned short *shortPtr = (unsigned short *) thisRegPtr;
  1379.         thisReg = (unsigned int) *shortPtr;
  1380.         break;
  1381.         }
  1382.         default: {
  1383.         panic("SCSI3: GetByte: unknown type.\n");
  1384.         thisReg = 0;
  1385.         break;
  1386.         }
  1387.     }
  1388.         
  1389.     if (devSCSI3Debug > 10 && i < 5) {
  1390.         printf("%d/%x ", i, thisReg);
  1391.     }
  1392.     switch(bitSel) {
  1393.         case ACTIVE_HIGH: {
  1394.         if ((thisReg & conditions) != 0) {
  1395.             return(SUCCESS);
  1396.         }
  1397.         break;
  1398.         }
  1399.         case ACTIVE_ALL: {
  1400.         if ((thisReg & conditions) == conditions) {
  1401.             return(SUCCESS);
  1402.         }
  1403.         break;
  1404.         }
  1405.         case ACTIVE_LOW: {
  1406.         if ((thisReg & conditions) != conditions) {
  1407.             return(SUCCESS);
  1408.         }
  1409.         break;
  1410.         }
  1411.         case ACTIVE_NONE: {
  1412.         if ((thisReg & conditions) == 0) {
  1413.             return(SUCCESS);
  1414.         }
  1415.         break;
  1416.         }
  1417.         default: {
  1418.         panic("SCSI3: bit selector: unknown type: %d.\n",
  1419.               (int) bitSel);
  1420.         break;
  1421.         }
  1422.     } 
  1423.     if (regsPtr->control & SI_CSR_DMA_BUS_ERR) {
  1424.         if (devSCSI3Debug > 5) {
  1425.             panic("SCSI3WaitReg: bus error\n");
  1426.         } else {
  1427.         printf("SCSI3WaitRes: bus error\n");
  1428.         }
  1429.         status = DEV_DMA_FAULT;
  1430.         break;
  1431. #ifdef notdef
  1432.     } else if (regsPtr->sbc.read.status & SBC_BSR_PERR) {
  1433.         if (devSCSI3Debug > 0) {
  1434.             panic("SCSI3: parity error\n");
  1435.         } else {
  1436.         printf("SCSI3: parity error\n");
  1437.         }
  1438.         status = DEV_DMA_FAULT;
  1439.         break;
  1440. #endif
  1441.     }
  1442.     MACH_DELAY(10);
  1443.     }
  1444.     if (devSCSI3Debug > 2) {
  1445.     printf("WaitReg: timed out.\n");
  1446.     PrintRegs(regsPtr);
  1447.     printf("WaitReg: was checking %x for condition(s) %x to go ",
  1448.            (int) thisRegPtr, (int) conditions);
  1449.     switch(bitSel) {
  1450.         case ACTIVE_HIGH: {
  1451.         printf("ACTIVE_HIGH.\n");
  1452.         break;
  1453.         }
  1454.         case ACTIVE_ALL: {
  1455.         printf("ACTIVE_ALL.\n");
  1456.         break;
  1457.         }
  1458.         case ACTIVE_LOW: {
  1459.         printf("ACTIVE_LOW.\n");
  1460.         break;
  1461.         }
  1462.         case ACTIVE_NONE: {
  1463.         printf("ACTIVE_NONE.\n");
  1464.         break;
  1465.         }
  1466.     } 
  1467.     
  1468.     }
  1469.     if (reset) {
  1470.     Reset(ctrlPtr);
  1471.     }
  1472.     return(status);
  1473. }
  1474.  
  1475. /*
  1476.  *----------------------------------------------------------------------
  1477.  *
  1478.  * WaitPhase --
  1479.  *
  1480.  *    Wait for a phase to be signalled in the controller registers.
  1481.  *     This is a specialized version of WaitReg, which compares
  1482.  *     all the phase bits to make sure the phase is exactly what is
  1483.  *    requested and not something that matches only in some bits.
  1484.  *
  1485.  * Results:
  1486.  *    SUCCESS if the condition occurred before a threshold time limit,
  1487.  *    DEV_TIMEOUT otherwise.
  1488.  *
  1489.  * Side effects:
  1490.  *    This resets the SCSI bus if the condition bits are not set by
  1491.  *    the controller before timeout.
  1492.  *
  1493.  *----------------------------------------------------------------------
  1494.  */
  1495. static ReturnStatus
  1496. WaitPhase(ctrlPtr, phase, reset)
  1497.     Controller *ctrlPtr;    /* Controller state */
  1498.     unsigned int phase;         /* phase to check */
  1499.     Boolean reset;        /* whether to reset the bus on error */
  1500. {
  1501.     volatile register CtrlRegs *regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  1502.     register int i;
  1503.     ReturnStatus status = DEV_TIMEOUT;
  1504.     register unsigned char thisReg;
  1505.  
  1506.     for (i=0 ; i<(WAIT_LENGTH/10) ; i++) {
  1507.     thisReg = regsPtr->sbc.read.curStatus;
  1508.     if (devSCSI3Debug > 10 && i < 5) {
  1509.         printf("%d/%x ", i, thisReg);
  1510.     }
  1511.     if ((thisReg & CBSR_PHASE_BITS) == phase) {
  1512.         return(SUCCESS);
  1513.     }
  1514.     if (regsPtr->control & SI_CSR_DMA_BUS_ERR) {
  1515.         if (devSCSI3Debug > 5) {
  1516.             panic("SCSI3WaitPhase: bus error\n");
  1517.         } else {
  1518.         printf("SCSI3WaitPhase: bus error\n");
  1519.         }
  1520.         status = DEV_DMA_FAULT;
  1521.         break;
  1522. #ifdef notdef
  1523.     } else if (regsPtr->sbc.read.status & SBC_BSR_PERR) {
  1524.         if (devSCSI3Debug > 0) {
  1525.             panic("SCSI3: parity error\n");
  1526.         } else {
  1527.         printf("SCSI3: parity error\n");
  1528.         }
  1529.         status = DEV_DMA_FAULT;
  1530.         break;
  1531. #endif
  1532.     }
  1533.     MACH_DELAY(10);
  1534.     }
  1535.     if (devSCSI3Debug > 5) {
  1536.     printf("WaitPhase: timed out.\n");
  1537.     PrintRegs(regsPtr);
  1538.     printf("WaitPhase: was checking for phase %x.\n",
  1539.            (int) phase);
  1540.     }
  1541.     if (reset) {
  1542.     Reset(ctrlPtr);
  1543.     }
  1544.     return(status);
  1545. }
  1546.  
  1547.  
  1548. /*
  1549.  *----------------------------------------------------------------------
  1550.  *
  1551.  * PutByte --
  1552.  *
  1553.  *    Put a byte onto the SCSI bus.  This always goes into the MSG_OUT
  1554.  *    phase.  This handles the standard REQ/ACK handshake to put
  1555.  *    the bytes on the SCSI bus.
  1556.  *
  1557.  * Results:
  1558.  *    None.
  1559.  *
  1560.  * Side effects:
  1561.  *    Yanks control lines in order to put a byte on the bus.
  1562.  *
  1563.  *----------------------------------------------------------------------
  1564.  */
  1565.  
  1566. #ifdef reselection
  1567. static ReturnStatus
  1568. PutByte(ctrlPtr, dataPtr)
  1569.     Controller *ctrlPtr;
  1570.     char *dataPtr;    
  1571. {
  1572.     volatile register CtrlRegs *regsPtr = (volatile CtrlRegs *) ctrlPtr->regsPtr;
  1573.     volatile unsigned char *initCmdPtr = ®sPtr->sbc.write.initCmd;
  1574.     register ReturnStatus status;
  1575.     unsigned char junk;
  1576.  
  1577.     /*
  1578.      * Enter MESSAGE OUT phase and wait for REQ to be set by the target.
  1579.      */
  1580.     regsPtr->sbc.write.trgtCmd = TCR_MSG_OUT;
  1581.     *initCmdPtr = 0;
  1582.     status = WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.curStatus,
  1583.                 REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_HIGH);
  1584.     if (status != SUCCESS) {
  1585.     if (devSCSI3Debug > 1) {
  1586.         printf("PutByte couldn't wait for REQ.\n");
  1587.     }
  1588.     return(status);
  1589.     }
  1590.     /*
  1591.      * Put the data on and then ACK the target's REQ.
  1592.      */
  1593.     regsPtr->sbc.write.data = *dataPtr;
  1594.     regsPtr->sbc.write.initCmd = SBC_ICR_DATA;
  1595.     regsPtr->sbc.write.initCmd |= SBC_ICR_ACK;
  1596.     status =  WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.curStatus,
  1597.                 REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_LOW);
  1598.     if (status != SUCCESS) {
  1599.     if (devSCSI3Debug > 1) {
  1600.         printf("Warning: %s wait on REQ line to go low failed.\n",
  1601.            ctrlPtr->name);
  1602.     }
  1603.     return(status);
  1604.     }    
  1605.  
  1606.     regsPtr->sbc.write.trgtCmd = TCR_UNSPECIFIED;
  1607.     junk = regsPtr->sbc.read.clear;
  1608. #ifdef lint
  1609.     regsPtr->sbc.read.clear = junk;
  1610. #endif
  1611.     regsPtr->sbc.write.initCmd = 0;
  1612.     return(SUCCESS);
  1613. }
  1614. #endif
  1615.  
  1616.  
  1617. /*
  1618.  *----------------------------------------------------------------------
  1619.  *
  1620.  * GetByte --
  1621.  *
  1622.  *    Get a byte from the SCSI bus, corresponding to the specified phase.
  1623.  *     This entails waiting for a request, checking the phase, reading
  1624.  *    the byte, and sending an acknowledgement.
  1625.  *
  1626.  * Results:
  1627.  *    None.
  1628.  *
  1629.  * Side effects:
  1630.  *    None.
  1631.  *
  1632.  *----------------------------------------------------------------------
  1633.  */
  1634.  
  1635. static ReturnStatus
  1636. GetByte(ctrlPtr, phase, charPtr)
  1637.     Controller *ctrlPtr;
  1638.     unsigned int phase;
  1639.     char *charPtr;    
  1640. {
  1641.     register volatile CtrlRegs *regsPtr = (volatile CtrlRegs *)ctrlPtr->regsPtr;
  1642.     ReturnStatus status;
  1643.     
  1644.     status = WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.curStatus,
  1645.                 REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_HIGH);
  1646.     if (status != SUCCESS) {
  1647.     return(status);
  1648.     }
  1649.     if ((regsPtr->sbc.read.curStatus & CBSR_PHASE_BITS) != phase) {
  1650.     if (devSCSI3Debug > 5) {
  1651.         printf("SCSI3: GetByte: wanted phase %x, got phase %x in curStatus %x.\n",
  1652.                phase, regsPtr->sbc.read.curStatus & CBSR_PHASE_BITS,
  1653.                regsPtr->sbc.read.curStatus);
  1654.     }
  1655.     /*
  1656.      * Use the "handshake error" to signal a new phase.  This should
  1657.      * be propagated into a new DEV status to signal a "condition" that
  1658.      * isn't an "error".
  1659.      */
  1660.     return(DEV_HANDSHAKE_ERROR);
  1661.     }
  1662.     *charPtr = regsPtr->sbc.read.data;
  1663.     regsPtr->sbc.write.initCmd = SBC_ICR_ACK;
  1664.     status = WaitReg(ctrlPtr, (Address) ®sPtr->sbc.read.curStatus,
  1665.                 REG_BYTE, SBC_CBSR_REQ, RESET, ACTIVE_LOW);
  1666.     if (status != SUCCESS) {
  1667.     panic("SCSI3: GetByte: request line didn't go low.\n");
  1668.     return(status);
  1669.     }
  1670.     if ((phase == PHASE_MSG_IN) && (*charPtr == SCSI_COMMAND_COMPLETE)) {
  1671.     regsPtr->sbc.write.initCmd = 0;
  1672.     regsPtr->sbc.write.mode &= ~SBC_MR_DMA;
  1673.     } else {
  1674.         regsPtr->sbc.write.initCmd = 0;
  1675.     }
  1676.     return(SUCCESS);
  1677. }
  1678.  
  1679.  
  1680. /*
  1681.  *----------------------------------------------------------------------
  1682.  *
  1683.  * PrintRegs --
  1684.  *
  1685.  *    Print out the interesting registers.  This could be a macro but
  1686.  *    then it couldn't be called from kdbx.  This routine is necessary
  1687.  *    because kdbx doesn't print all the character values properly.
  1688.  *
  1689.  * Results:
  1690.  *    None.
  1691.  *
  1692.  * Side effects:
  1693.  *    Data is displayed on the console or to the debugger.
  1694.  *
  1695.  *----------------------------------------------------------------------
  1696.  */
  1697. static void
  1698. PrintRegs(regsPtr)
  1699.     register volatile CtrlRegs *regsPtr;
  1700. {
  1701.     printf("ctl %x addr %x%x dmaCount %x%x fifoCount %x%x data %x\n\tinitCmd %x mode %x target %x curStatus %x status %x\n", 
  1702.            regsPtr->control,
  1703.            regsPtr->dmaAddressHigh,
  1704.            regsPtr->dmaAddressLow,
  1705.            regsPtr->dmaCountHigh,
  1706.            regsPtr->dmaCountLow,
  1707.            regsPtr->fifoCountHigh,
  1708.            regsPtr->fifoCountLow,
  1709.            regsPtr->sbc.read.data,
  1710.            regsPtr->sbc.read.initCmd, 
  1711.            regsPtr->sbc.read.mode,
  1712.            regsPtr->sbc.read.trgtCmd, 
  1713.            regsPtr->sbc.read.curStatus,
  1714.            regsPtr->sbc.read.status);
  1715. }
  1716.  
  1717. /*
  1718.  *----------------------------------------------------------------------
  1719.  *
  1720.  *  SpecialSenseProc --
  1721.  *
  1722.  *    Special function used for HBA generated REQUEST SENSE. A SCSI
  1723.  *    command request with this function as a call back proc will
  1724.  *    be processed by routine RequestDone as a result of a 
  1725.  *    REQUEST SENSE. This routine is never called.
  1726.  *
  1727.  * Results:
  1728.  *    None.
  1729.  *
  1730.  * Side effects:
  1731.  *    None.
  1732.  *
  1733.  *----------------------------------------------------------------------
  1734.  */
  1735.  
  1736. static int
  1737. SpecialSenseProc()
  1738. {
  1739.     return 0;
  1740. }
  1741.  
  1742.  
  1743. /*
  1744.  *----------------------------------------------------------------------
  1745.  *
  1746.  * RequestDone --
  1747.  *
  1748.  *    Process a request that has finished. Unless a SCSI check condition
  1749.  *    bit is present in the status returned, the request call back
  1750.  *    function is called.  If check condition is set we fire off a
  1751.  *    SCSI REQUEST SENSE to get the error sense bytes from the device.
  1752.  *
  1753.  * Results:
  1754.  *    None.
  1755.  *
  1756.  * Side effects:
  1757.  *    The call back function may be called.
  1758.  *
  1759.  *----------------------------------------------------------------------
  1760.  */
  1761.  
  1762. static void
  1763. RequestDone(devPtr,scsiCmdPtr,status,scsiStatusByte,amountTransferred)
  1764.     Device    *devPtr;    /* Device for request. */
  1765.     ScsiCmd    *scsiCmdPtr;    /* Request that finished. */
  1766.     ReturnStatus status;    /* Status returned. */
  1767.     unsigned char scsiStatusByte;    /* SCSI Status Byte. */
  1768.     int        amountTransferred; /* Amount transferred by command. */
  1769. {
  1770.     ReturnStatus    senseStatus;
  1771.     Controller            *ctrlPtr = devPtr->ctrlPtr;
  1772.  
  1773.  
  1774.     if (devSCSI3Debug > 3) {
  1775.     printf("RequestDone for %s status 0x%x scsistatus 0x%x count %d\n",
  1776.         devPtr->handle.locationName, status,scsiStatusByte,
  1777.         amountTransferred);
  1778.     }
  1779.     /*
  1780.      * Unallocated any DMA allocated for this request. 
  1781.      */
  1782.     if (ctrlPtr->dmaBuffer != (Address) NIL) {
  1783.     VmMach_DMAFree(scsiCmdPtr->bufferLen, ctrlPtr->dmaBuffer);
  1784.     ctrlPtr->dmaBuffer = (Address) NIL;
  1785.     }
  1786.     /*
  1787.      * First check to see if this is the reponse of a HBA generated 
  1788.      * REQUEST SENSE command.  If this is the case, we can process
  1789.      * the callback of the frozen command for this device and
  1790.      * allow the flow of command to the device to be resummed.
  1791.      */
  1792.     if (scsiCmdPtr->doneProc == SpecialSenseProc) {
  1793.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  1794.     (devPtr->frozen.scsiCmdPtr->doneProc)(devPtr->frozen.scsiCmdPtr, 
  1795.             SUCCESS,
  1796.             devPtr->frozen.statusByte, 
  1797.             devPtr->frozen.amountTransferred,
  1798.             amountTransferred,
  1799.             devPtr->senseBuffer);
  1800.          MASTER_LOCK(&(ctrlPtr->mutex));
  1801.      SET_CTRL_FREE(ctrlPtr);
  1802.      return;
  1803.     }
  1804.     /*
  1805.      * This must be a outside request finishing. If the request 
  1806.      * suffered an error or the HBA or the scsi status byte
  1807.      * says there is no error sense present, we can do the
  1808.      * callback and free the controller.
  1809.      */
  1810.     if ((status != SUCCESS) || !SCSI_CHECK_STATUS(scsiStatusByte)) {
  1811.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  1812.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  1813.                    amountTransferred, 0, (char *) 0);
  1814.         MASTER_LOCK(&(ctrlPtr->mutex));
  1815.      SET_CTRL_FREE(ctrlPtr);
  1816.      return;
  1817.    } 
  1818.    /*
  1819.     * If we got here than the SCSI command came back from the device
  1820.     * with the CHECK bit set in the status byte.
  1821.     * Need to perform a REQUEST SENSE. Move the current request 
  1822.     * into the frozen state and issue a REQUEST SENSE. 
  1823.     */
  1824.    devPtr->frozen.scsiCmdPtr = scsiCmdPtr;
  1825.    devPtr->frozen.statusByte = scsiStatusByte;
  1826.    devPtr->frozen.amountTransferred = amountTransferred;
  1827.    DevScsiSenseCmd((ScsiDevice *)devPtr, DEV_MAX_SENSE_BYTES, 
  1828.            devPtr->senseBuffer, &(devPtr->SenseCmd));
  1829.    devPtr->SenseCmd.doneProc = SpecialSenseProc,
  1830.    senseStatus = SendCommand(devPtr, &(devPtr->SenseCmd));
  1831.    /*
  1832.     * If we got an HBA error on the REQUEST SENSE we end the outside 
  1833.     * command with the SUCCESS status but zero sense bytes returned.
  1834.     */
  1835.    if (senseStatus != SUCCESS) {
  1836.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  1837.     (scsiCmdPtr->doneProc)(scsiCmdPtr, status, scsiStatusByte,
  1838.                    amountTransferred, 0, (char *) 0);
  1839.         MASTER_LOCK(&(ctrlPtr->mutex));
  1840.     SET_CTRL_FREE(ctrlPtr);
  1841.    }
  1842.  
  1843. }
  1844.  
  1845. /*
  1846.  *----------------------------------------------------------------------
  1847.  *
  1848.  * entryAvailProc --
  1849.  *
  1850.  *    Act upon an entry becomming available in the queue for this
  1851.  *    controller. This routine is the Dev_Queue callback function that
  1852.  *    is called whenever work becomes available for this controller. 
  1853.  *    If the controller is not already busy we dequeue and start the
  1854.  *    request.
  1855.  *    NOTE: This routine is also called from DevSCSI3Intr to start the
  1856.  *    next request after the previously one finishes.
  1857.  *
  1858.  * Results:
  1859.  *    None.
  1860.  *
  1861.  * Side effects:
  1862.  *    Request may be dequeue and submitted to the device. Request callback
  1863.  *    function may be called.
  1864.  *
  1865.  *----------------------------------------------------------------------
  1866.  */
  1867.  
  1868. static Boolean
  1869. entryAvailProc(clientData, newRequestPtr) 
  1870.    ClientData    clientData;    /* Really the Device this request ready. */
  1871.    List_Links *newRequestPtr;    /* The new SCSI request. */
  1872. {
  1873.     register Device *devPtr; 
  1874.     register Controller *ctrlPtr;
  1875.     register ScsiCmd    *scsiCmdPtr;
  1876.     ReturnStatus    status;
  1877.  
  1878.     devPtr = (Device *) clientData;
  1879.     ctrlPtr = devPtr->ctrlPtr;
  1880.     /*
  1881.      * If we are busy (have an active request) just return. Otherwise 
  1882.      * start the request.
  1883.      */
  1884.  
  1885.     if (IS_CTRL_BUSY(ctrlPtr)) { 
  1886.     return FALSE;
  1887.     }
  1888. again:
  1889.     scsiCmdPtr = (ScsiCmd *) newRequestPtr;
  1890.     devPtr = (Device *) clientData;
  1891.     status = SendCommand(devPtr, scsiCmdPtr);
  1892.     /*    
  1893.      * If the command couldn't be started do the callback function.
  1894.      */
  1895.     if (status != SUCCESS) {
  1896.      RequestDone(devPtr,scsiCmdPtr,status,0,0);
  1897.     }
  1898.     if (!IS_CTRL_BUSY(ctrlPtr)) { 
  1899.         newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  1900.                 DEV_QUEUE_ANY_QUEUE_MASK,&clientData);
  1901.     if (newRequestPtr != (List_Links *) NIL) { 
  1902.         goto again;
  1903.     }
  1904.     }
  1905.     return TRUE;
  1906.  
  1907. }   
  1908.  
  1909.  
  1910.  
  1911. /*
  1912.  *----------------------------------------------------------------------
  1913.  *
  1914.  * DevSCSI3Intr --
  1915.  *
  1916.  * Handle interrupts from the SCSI-3 controller.
  1917.  * The follow cases cause interrupts on the 5380: => SBC_IP
  1918.  *    1. Reselection attempt by a target (not implemented yet)
  1919.  *    2. EOP during DMA.  This indicates DMA has completed.
  1920.  *    3. SCSI bus reset.  (Only applies to targets, not us.)
  1921.  *    4. Parity error during data transfer.  (Parity checking is disabled.)
  1922.  *    5. Bus phase mismatch.  trgtCmd must be correct for data transfers.
  1923.  *    6. SCSI bus disconnect by a target (not implmented yet)
  1924.  * In addition the SCSI-3 Host Adaptor will generate interrupts when:
  1925.  *    7. Registers other than control are touched during DMA => DMA_CONFLICT
  1926.  *    8. An error occurs during DMA. => DMA_IP
  1927.  *
  1928.  * Results:
  1929.  *    TRUE if an SCSI3 controller was responsible for the interrupt
  1930.  *    and this routine handled it.
  1931.  *
  1932.  * Side effects:
  1933.  *    Usually a process is notified that an I/O has completed.
  1934.  *
  1935.  *----------------------------------------------------------------------
  1936.  */
  1937. Boolean 
  1938. DevSCSI3Intr(clientDataArg)
  1939.     ClientData    clientDataArg;
  1940. {
  1941.     Controller *ctrlPtr;
  1942.     register volatile CtrlRegs *regsPtr;
  1943.     Device    *devPtr;
  1944.     unsigned char statusByte;
  1945.     ReturnStatus status;
  1946.     int byteCount;
  1947.     int amountToDma;
  1948.     char *offset;
  1949.     register int i;
  1950.     unsigned char phase;
  1951.     unsigned char foo;
  1952.     int     residual;
  1953.     List_Links    *newRequestPtr;
  1954.     ClientData    clientData;
  1955.  
  1956.     if (devSCSI3Debug > 4) {
  1957.     printf("DevSCSI3Intr: ");
  1958.     }
  1959.     ctrlPtr = (Controller *) clientDataArg;
  1960.     regsPtr = ctrlPtr->regsPtr;
  1961.     devPtr = ctrlPtr->devPtr;
  1962.     if ((regsPtr->control & (SI_CSR_SBC_IP |    /* 5380 interrupt */
  1963.                  SI_CSR_DMA_IP |        /* or DMA error */
  1964.                  SI_CSR_DMA_CONFLICT))    /* or register goof */
  1965.                  == 0) {
  1966.     if (devSCSI3Debug > 4 ) {
  1967.         printf("spurious\n");
  1968.     }
  1969.     return FALSE;
  1970.     }
  1971.     MASTER_LOCK(&(ctrlPtr->mutex));
  1972.     if (ctrlPtr->scsiCmdPtr != (ScsiCmd *) NIL) {
  1973.     residual = ctrlPtr->scsiCmdPtr->bufferLen;
  1974.     } else {
  1975.     residual = 0;
  1976.     }
  1977.     /*
  1978.      * First, disable DMA or else we'll get register conflicts.
  1979.      */
  1980.     if (!ctrlPtr->onBoard) {
  1981.     regsPtr->control &= ~SI_CSR_DMA_EN;
  1982.     byteCount = ctrlPtr->dmaSetup ? READ_FIFO_COUNT(regsPtr) : residual;
  1983.     } else { 
  1984.     byteCount = READ_FIFO_COUNT(regsPtr);
  1985.     }
  1986.     regsPtr->sbc.write.trgtCmd = TCR_UNSPECIFIED;
  1987.     /*
  1988.      * The follow cases cause interrupts on the 5380:
  1989.      *    1. Selection or Reselection (only reselection applies to the CPU)
  1990.      *    2. EOP during DMA.  This indicates DMA has completed.
  1991.      *    3. SCSI bus reset.  This probably shouldn't happen; we do the resetting
  1992.      *    4. Parity error during data transfer.  Parity checking is disabled.
  1993.      *    5. Bus phase mismatch.  trgtCmd must be correct for data transfers.
  1994.      *    6. SCSI bus disconnect.  A target is disconnecting.
  1995.      * In addition the Host Adaptor will generate interrupts when:
  1996.      *    7. Registers other than control are touched during DMA => DMA_CONFLICT
  1997.      *    8. An error occurs during DMA. => DMA_IP
  1998.      */
  1999.     if (regsPtr->control & (SI_CSR_DMA_IP | SI_CSR_DMA_CONFLICT)) {
  2000.     /*
  2001.      * DMA Error.  DMA_IP means a bus error or
  2002.      *            "send & fifo-empty & dmaCount == 0"
  2003.      *    DMA_CONFLICT means we touched a non-control reg during DMA.
  2004.      */
  2005.     if (regsPtr->control & SI_CSR_DMA_BUS_ERR) {
  2006.         /*
  2007.          * A Bus Error.  Complete the I/O but flag an error.
  2008.          * The residual is computed because the Bus Error could
  2009.          * have occurred after a number of sectors.
  2010.          */
  2011.         residual = byteCount;
  2012.         printf("Warning: %s DMA bus error\n",ctrlPtr->name);
  2013.     } else if (regsPtr->control & SI_CSR_DMA_CONFLICT) {
  2014.         printf("Warning: %s DMA register conflict goof\n",ctrlPtr->name);
  2015.     } else {
  2016.         printf("Warning: %s DMA programming error\n",ctrlPtr->name);
  2017.     }
  2018.     status = DEV_DMA_FAULT;
  2019.     goto rtnHardErrorAndGetNext;    /* Return the hard error message
  2020.                      * to the call and get the next 
  2021.                      * entry in the devQueue. */
  2022.     }
  2023.     /*
  2024.      * 5380 generated interrupt.
  2025.      * Interrupt processing is described on pages 86-89.
  2026.      *    Parity is turned off, so SBC_BSR_PERR can be ignored.
  2027.      *    Busy monitoring mode is not set, so SBC_BSR_BERR can be ignored.
  2028.      */
  2029.     if (regsPtr->sbc.read.curStatus & SBC_CBSR_SEL) {
  2030.     /*
  2031.      * Reselection attempt by a target.  Unimplementned.
  2032.      */
  2033.     printf("Warning: %s reselection attempt!\n",ctrlPtr->name);
  2034.     foo = regsPtr->sbc.read.clear;
  2035.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2036.     return(TRUE);
  2037.     }
  2038.     /*
  2039.      * SBC_BSR_EDMA may be set to indicate that DMA has completed,
  2040.      * or the SBC_BSR_PMTCH bit is 0 (this has been verified).
  2041.      * We fall through and test the REQ line to see if the target
  2042.      * is trying to send additional data bytes, or we are just
  2043.      * getting a standard phase change interrupt.
  2044.      */
  2045.     for (i=0 ; i<30 ; i++) {
  2046.     if (regsPtr->sbc.read.curStatus & SBC_CBSR_REQ) {
  2047.         break;
  2048.     }
  2049.     MACH_DELAY(10);
  2050.     }
  2051.     foo = regsPtr->sbc.read.clear;
  2052. #ifdef lint        
  2053.     regsPtr->sbc.read.clear = foo;
  2054. #endif
  2055.     if (i == 30) {
  2056.     /*
  2057.      * Apparently spurious interrupt, cause as yet unknown.
  2058.      */
  2059.     if (devSCSI3Debug > 4) {
  2060.         printf("REQ not set: CBSR %x BSR %x\n",
  2061.         regsPtr->sbc.read.curStatus, regsPtr->sbc.read.status);
  2062.     }
  2063.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2064.     return(TRUE);
  2065.     }
  2066.     phase = regsPtr->sbc.read.curStatus & CBSR_PHASE_BITS;
  2067.     switch (phase) {
  2068.     case PHASE_DATA_IN:
  2069.     case PHASE_DATA_OUT: {
  2070.         if (devSCSI3Debug > 4) {
  2071.         printf("Data Phase Interrupt\n");
  2072.         }
  2073.         regsPtr->sbc.write.mode &= ~SBC_MR_DMA;
  2074.         StartDMA(ctrlPtr);
  2075.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  2076.         return(TRUE);
  2077.     }
  2078.     case PHASE_MSG_IN: {
  2079.         char    message;
  2080.         status = GetByte(ctrlPtr, PHASE_MSG_IN, (char *)&message);
  2081.         if (devSCSI3Debug > 4) {
  2082.         printf("Msg Phase Interrupt\n");
  2083.         }
  2084.         if (status != SUCCESS) {
  2085.         printf("Warning: %s couldn't get message.\n",ctrlPtr->name);
  2086.         if (!ctrlPtr->onBoard) {
  2087.             regsPtr->control |= SI_CSR_DMA_EN;
  2088.         }
  2089.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  2090.         return(TRUE);
  2091.         }
  2092.         if (message != SCSI_COMMAND_COMPLETE) {
  2093.         printf("Warning: %s couldn't handle message 0x%x from %s.\n",
  2094.             ctrlPtr->name, message, 
  2095.             ctrlPtr->devPtr->handle.locationName);
  2096.         if (!ctrlPtr->onBoard) {
  2097.             regsPtr->control |= SI_CSR_DMA_EN;
  2098.         }
  2099.         }
  2100.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  2101.         return(TRUE);
  2102.     }
  2103.     case PHASE_STATUS: {
  2104.         if (ctrlPtr->onBoard) {
  2105.         residual = byteCount;
  2106.         } else {
  2107.         residual = ctrlPtr->dmaSetup ? READ_DMA_COUNT(regsPtr) :
  2108.                         byteCount;
  2109.         }
  2110.         if (devSCSI3Debug > 4) {
  2111.         printf("Status Phase Interrupt, residual = %d\n",residual);
  2112.         }
  2113.         if (ctrlPtr->dmaState == DMA_RECEIVE) {
  2114.         if (!ctrlPtr->onBoard) { 
  2115.             if ((regsPtr->control & SI_CSR_LOB) != 0) {
  2116.             /*
  2117.              * On a read the last odd byte is left in the byte pack
  2118.              * register. We use wordmode (not 32-bit longwords)
  2119.              * so there will only be one byte left.  I assume it
  2120.              * is Byte 0 in the byte pack reg, with is the first
  2121.              * byte in the high-half.
  2122.              */ 
  2123.             *(char *) (READ_DMA_ADDR(regsPtr) + VMMACH_DMA_START_ADDR) = 
  2124.                 (regsPtr->bytePackHigh & 0xff00) >> 8;
  2125.             }
  2126.         } else {
  2127.             regsPtr->udcRaddr = UDC_ADR_COUNT;
  2128.             /*
  2129.              * wait for the fifo to empty
  2130.              */
  2131.             status = WaitReg(ctrlPtr, (Address)®sPtr->control,
  2132.                 REG_SHORT, SI_CSR_FIFO_EMPTY, RESET, ACTIVE_HIGH);
  2133.             if (status != SUCCESS) {
  2134.             printf("Warning: %s fifo wait failed\n",ctrlPtr->name);
  2135.             }
  2136.             amountToDma = ctrlPtr->scsiCmdPtr->bufferLen;
  2137. #ifdef notdef
  2138.             if ((byteCount == amountToDma)  ||
  2139.             (byteCount + 1 == amountToDma)) {
  2140.                 goto out;
  2141.             /*
  2142.              * Didn't transfer any data.
  2143.              * The fifoCount + 1 above wards against 5380 prefetch.
  2144.              */
  2145.                 goto out;
  2146.             }
  2147. #endif
  2148.             /*
  2149.              * Transfer left over byte or shortword by hand
  2150.              */
  2151.             offset = ctrlPtr->scsiCmdPtr->buffer +
  2152.                 amountToDma - byteCount;
  2153.             if ((amountToDma - byteCount) & 1) {
  2154.             offset[-1] = (regsPtr->fifoData & 0xff00) >> 8;
  2155.             } else if (((regsPtr->udcRdata*2) - byteCount) == 2) {
  2156.             offset[-2] = (regsPtr->fifoData & 0xff00) >> 8;
  2157.             offset[-1] = (regsPtr->fifoData & 0xff);
  2158.             }
  2159.         }
  2160.         }
  2161.  
  2162.         status =  GetStatusByte(ctrlPtr, &statusByte);
  2163.         if (status != SUCCESS) {
  2164.                     /* Return the hard error message
  2165.                      * to the call and get the next 
  2166.                      * entry in the devQueue. */
  2167.         goto rtnHardErrorAndGetNext;
  2168.         }
  2169.         RequestDone(devPtr, ctrlPtr->scsiCmdPtr, status, statusByte,
  2170.             ctrlPtr->scsiCmdPtr->bufferLen - residual);
  2171.         if (!IS_CTRL_BUSY(ctrlPtr)) {
  2172.             newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  2173.                 DEV_QUEUE_ANY_QUEUE_MASK,&clientData);
  2174.         if (newRequestPtr != (List_Links *) NIL) { 
  2175.             (void) entryAvailProc(clientData,newRequestPtr);
  2176.         }
  2177.         }
  2178.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  2179.         return(TRUE);
  2180.     }
  2181.     default: {
  2182.         printf("Warning: %s couldn't handle phase %x... ignoring.\n",
  2183.                ctrlPtr->name, phase);
  2184.         if (devSCSI3Debug > 0) {
  2185.         PrintRegs(regsPtr);
  2186.         }
  2187.         if (!ctrlPtr->onBoard) {
  2188.         regsPtr->control |= SI_CSR_DMA_EN;
  2189.         }
  2190.         MASTER_UNLOCK(&(ctrlPtr->mutex));
  2191.         return(TRUE);
  2192.     }
  2193.     }
  2194.     /*
  2195.      * Jump here to return an error and reset the HBA.
  2196.      */
  2197. rtnHardErrorAndGetNext:
  2198.     if (ctrlPtr->scsiCmdPtr != (ScsiCmd *) NIL) { 
  2199.     printf("Warning: %s reset and current command terminated.\n",
  2200.            devPtr->handle.locationName);
  2201.     RequestDone(devPtr,ctrlPtr->scsiCmdPtr,status,0,residual);
  2202.     }
  2203.     Reset(ctrlPtr);
  2204.     /*
  2205.      * Use the queue entryAvailProc to start the next request for this device.
  2206.      */
  2207.     newRequestPtr = Dev_QueueGetNextFromSet(ctrlPtr->devQueues,
  2208.                 DEV_QUEUE_ANY_QUEUE_MASK,&clientData);
  2209.     if (newRequestPtr != (List_Links *) NIL) { 
  2210.     (void) entryAvailProc(clientData,newRequestPtr);
  2211.     }
  2212.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2213.     return (TRUE);
  2214.  
  2215. }
  2216.  
  2217. /*
  2218.  *----------------------------------------------------------------------
  2219.  *
  2220.  * ReleaseProc --
  2221.  *
  2222.  *    Device release proc for controller.
  2223.  *
  2224.  * Results:
  2225.  *    None.
  2226.  *
  2227.  * Side effects:
  2228.  *    None.
  2229.  *
  2230.  *----------------------------------------------------------------------
  2231.  */
  2232. /*ARGSUSED*/
  2233. static ReturnStatus
  2234. ReleaseProc(scsiDevicePtr)
  2235.     ScsiDevice    *scsiDevicePtr;
  2236. {
  2237.     return SUCCESS;
  2238. }
  2239.  
  2240.  
  2241. /*
  2242.  *----------------------------------------------------------------------
  2243.  *
  2244.  * DevSCSI3Init --
  2245.  *
  2246.  *    Check for the existant of the Sun SCSI3 HBA controller. If it
  2247.  *    exists allocate data stuctures for it.
  2248.  *
  2249.  * Results:
  2250.  *    TRUE if the controller exists, FALSE otherwise.
  2251.  *
  2252.  * Side effects:
  2253.  *    Memory may be allocated.
  2254.  *
  2255.  *----------------------------------------------------------------------
  2256.  */
  2257. ClientData
  2258. DevSCSI3Init(ctrlLocPtr)
  2259.     DevConfigController    *ctrlLocPtr;    /* Controller location. */
  2260. {
  2261.     int    ctrlNum;
  2262.     Boolean    found;
  2263.     Controller *ctrlPtr;
  2264.     int    i,j;
  2265.  
  2266.     /*
  2267.      * See if the controller is there. 
  2268.      */
  2269.     ctrlNum = ctrlLocPtr->controllerID;
  2270.     found =  (ctrlLocPtr->space == DEV_OBIO) ? 
  2271.           ProbeOnBoard(ctrlLocPtr->address)  :
  2272.           ProbeVME(ctrlLocPtr->address);
  2273.     if (!found) {
  2274.     return DEV_NO_CONTROLLER;
  2275.     }
  2276.     /*
  2277.      * It's there. Allocate and fill in the Controller structure.
  2278.      */
  2279.     if (ctrlNum+1 > numSCSI3Controllers) {
  2280.     numSCSI3Controllers = ctrlNum+1;
  2281.     }
  2282.     Controllers[ctrlNum] = ctrlPtr = (Controller *) malloc(sizeof(Controller));
  2283.     bzero((char *) ctrlPtr, sizeof(Controller));
  2284.     ctrlPtr->regsPtr = (volatile CtrlRegs *) (ctrlLocPtr->address);
  2285.     if (ctrlLocPtr->space == DEV_OBIO) {
  2286.     ctrlPtr->onBoard = TRUE;
  2287.     ctrlPtr->udcDmaTable = (UDCDMAtable *) 
  2288.         VmMach_DMAAlloc(sizeof(UDCDMAtable), malloc(sizeof(UDCDMAtable)));
  2289.         if (ctrlPtr->udcDmaTable == (UDCDMAtable *) NIL) {
  2290.         panic("DevSCSI3Init: unable to allocate DMA memory.\n");
  2291.         }
  2292.     } else {
  2293.     ctrlPtr->onBoard = FALSE;
  2294.     /*
  2295.      * Set the address modifier in the interrupt vector.
  2296.      */
  2297.     ctrlPtr->regsPtr->addrIntr = INTR_ADDR(ctrlLocPtr->vectorNumber);
  2298.     }
  2299.     ctrlPtr->name = ctrlLocPtr->name;
  2300.     Sync_SemInitDynamic(&(ctrlPtr->mutex),ctrlPtr->name);
  2301.     /* 
  2302.      * Initialized the name, device queue header, and the master lock.
  2303.      * The controller comes up with no devices active and no devices
  2304.      * attached.  Reserved the devices associated with the 
  2305.      * targetID of the controller (7).
  2306.      */
  2307.     ctrlPtr->devQueues = Dev_CtrlQueuesCreate(&(ctrlPtr->mutex),entryAvailProc);
  2308.     for (i = 0; i < 8; i++) {
  2309.     for (j = 0; j < 8; j++) {
  2310.         ctrlPtr->devicePtr[i][j] = (i == 7) ? (Device *) 0 : (Device *) NIL;
  2311.     }
  2312.     }
  2313.     ctrlPtr->scsiCmdPtr = (ScsiCmd *) NIL;
  2314.     Controllers[ctrlNum] = ctrlPtr;
  2315.     Reset(ctrlPtr);
  2316.     return (ClientData) ctrlPtr;
  2317. }
  2318.  
  2319.  
  2320. /*
  2321.  *----------------------------------------------------------------------
  2322.  *
  2323.  * DevSCSI3AttachDevice --
  2324.  *
  2325.  *    Attach a SCSI device using the Sun SCSI3 HBA. 
  2326.  *
  2327.  * Results:
  2328.  *    None.
  2329.  *
  2330.  * Side effects:
  2331.  *    None.
  2332.  *
  2333.  *----------------------------------------------------------------------
  2334.  */
  2335.  
  2336. ScsiDevice   *
  2337. DevSCSI3AttachDevice(devicePtr, insertProc)
  2338.     Fs_Device    *devicePtr;     /* Device to attach. */
  2339.     void    (*insertProc)(); /* Queue insert procedure. */
  2340. {
  2341.     Device *devPtr;
  2342.     Controller    *ctrlPtr;
  2343.     char   tmpBuffer[512];
  2344.     int       length;
  2345.     int       ctrlNum;
  2346.     int       targetID, lun;
  2347.  
  2348.     /*
  2349.      * First find the SCSI3 controller this device is on.
  2350.      */
  2351.     ctrlNum = SCSI_HBA_NUMBER(devicePtr);
  2352.     if ((ctrlNum > MAX_SCSI3_CTRLS) ||
  2353.     (Controllers[ctrlNum] == (Controller *) 0)) { 
  2354.     return (ScsiDevice  *) NIL;
  2355.     } 
  2356.     ctrlPtr = Controllers[ctrlNum];
  2357.     targetID = SCSI_TARGET_ID(devicePtr);
  2358.     lun = SCSI_LUN(devicePtr);
  2359.     /*
  2360.      * Allocate a device structure for the device and fill in the
  2361.      * handle part. This must be created before we grap the MASTER_LOCK.
  2362.      */
  2363.     devPtr = (Device *) malloc(sizeof(Device)); 
  2364.     bzero((char *) devPtr, sizeof(Device));
  2365.     devPtr->handle.devQueue = Dev_QueueCreate(ctrlPtr->devQueues,
  2366.                 1, insertProc, (ClientData) devPtr);
  2367.     devPtr->handle.locationName = "Unknown";
  2368.     devPtr->handle.LUN = lun;
  2369.     devPtr->handle.releaseProc = ReleaseProc;
  2370.     devPtr->handle.maxTransferSize = (ctrlPtr->onBoard) ? 
  2371.                     MAX_ONBOARD_TRANSFER_SIZE :
  2372.                     MAX_VME_TRANSFER_SIZE;
  2373.     if (!ctrlPtr->onBoard) {
  2374.     countHighMask = 0xff;
  2375.     }
  2376.     devPtr->targetID = targetID;
  2377.     devPtr->ctrlPtr = ctrlPtr;
  2378.     MASTER_LOCK(&(ctrlPtr->mutex));
  2379.     /*
  2380.      * A device pointer of zero means that targetID/LUN 
  2381.      * conflicts with that of the HBA. A NIL means the
  2382.      * device hasn't been attached yet.
  2383.      */
  2384.     if (ctrlPtr->devicePtr[targetID][lun] == (Device *) 0) {
  2385.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2386.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  2387.     free((char *) devPtr);
  2388.     return (ScsiDevice *) NIL;
  2389.     }
  2390.     if (ctrlPtr->devicePtr[targetID][lun] != (Device *) NIL) {
  2391.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2392.     (void) Dev_QueueDestroy(devPtr->handle.devQueue);
  2393.     free((char *) devPtr);
  2394.     return (ScsiDevice *) (ctrlPtr->devicePtr[targetID][lun]);
  2395.     }
  2396.  
  2397.     ctrlPtr->devicePtr[targetID][lun] = devPtr;
  2398.     MASTER_UNLOCK(&(ctrlPtr->mutex));
  2399.     (void) sprintf(tmpBuffer, "%s Target %d LUN %d", ctrlPtr->name,
  2400.             devPtr->targetID, devPtr->handle.LUN);
  2401.     length = strlen(tmpBuffer);
  2402.     devPtr->handle.locationName = (char *) strcpy(malloc(length+1),tmpBuffer);
  2403.  
  2404.     return (ScsiDevice *) devPtr;
  2405. }
  2406.  
  2407.  
  2408.